Cm How It Work

CodyMaster Kit — The Ultimate Vibe Coding Guide

Overview

The CodyMaster (CM) kit transforms ideas into production code through 13 specialized, optimized skills. This workflow ensures the highest quality, absolute security, and maximum execution speed.

💡 Idea → 🔍 Analysis → 📐 Design → 🧪 Test-first (TDD) → 💻 Code → ✅ Verify → 🚀 Deploy → 🔄 Iterate

Workflow

Phase 0: Identity & Safety 🔒

Rule #1: Always verify identity before performing any action that could change the project state.

• Skill: cm-identity-guard
• When: At the start of a work session, before git push, deploy, or database operations.
• Action: Run node check-identity.js (or similar script) to verify GitHub/Cloudflare/Supabase accounts.

Phase 0.3: Knowledge Infrastructure Setup 🧠

For large codebases, establish the memory foundation before planning.

• Skills: cm-codeintell + cm-dockit + cm-deep-search + cm-notebooklm
• When: When onboarding to a new codebase or starting a massive refactoring initiative.
• Action:
  1. Scan structure with cm-codeintell to build the Skeleton Index.
  2. Generate missing architectural docs with cm-dockit.
  3. Index the docs for fast local retrieval with cm-deep-search (qmd).
  4. Sync high-value patterns to the Cloud Brain with cm-notebooklm.
• Output: A fully indexed 5-tier memory ecosystem ready for precise, low-token AI problem solving.

Phase 0.5: Strategic Analysis 🔍

For complex initiatives and enhancements on existing products.

• Skills: cm-brainstorm-idea + cm-codeintell
• When: When the task is complex and requires multi-dimensional analysis (tech, product, design, business) before planning.
• Action:
  1. Scan codebase with code intelligence (AST graph + architecture diagram via cm-codeintell).
  2. Interview user and analyze with 9 Windows (TRIZ).
  3. Propose 2-3 options, evaluate multi-dimensionally, recommend the best option.
• Output: OpenSpec openspec/changes/[initiative]/proposal.md — qualified problem + recommended option → passes to cm-planning.

Phase 1: Planning & Design 📐

Understand the 'Job to be Done' (JTBD) and architecture before writing code.

• Skill: cm-planning (Combines brainstorming + writing-plans)
• Action:
  1. Brainstorm requirements and analyze i18n.
  2. Propose architecture and tech stack.
  3. Write detailed OpenSpec docs (openspec/changes/[init]/design.md and tasks.md).
• Output: Design docs and execution plan (OpenSpec tasks) approved by user.

Phase 2: Implementation (TDD & Execution) 💻

Turn the plan into actual source code safely.

• Skills:
  • cm-tdd: Red-Green-Refactor cycle. No production code without a failing test first.
  • cm-execution: Execute plans intelligently (Manual, Parallel, or Subagent mode).
  • cm-project-bootstrap: For new projects — setup repo, i18n, SEO, and deploy pipeline from Day 0.
  • cm-execution: Isolate different work items to avoid state mixing.

Phase 3: Quality Control & Verification ✅

Prove with evidence, not words.

• Skills:
  • cm-quality-gate: Setup test infrastructure (test:gate) and verify output before claiming "done".
  • cm-debugging: When tests fail, use systematic investigation framework to find root cause.
  • cm-code-review: Professional request and feedback review process.

Phase 4: Safe Deployment 🚀

Ship code without fear of incidents.

• Skills:
  • cm-safe-deploy: Run 8-gate pipeline (Secret → Syntax → Test → Build → Deploy → Smoke).
  • cm-safe-i18n: Translate and synchronize languages consistently across the entire project.
  • cm-terminal: Monitor all terminal commands to detect errors immediately.

CodyMaster Kit — 34 Skills Summary

🔧 Engineering

⚙️ Operations

🎨 Product

📈 Growth

🎯 Orchestration

🖥️ Workflow Commands

🚀 Autonomous Workflow System

The kit supports autonomous mode by applying the Reason → Act → Reflect → Verify (RARV) loop.

How to Use the Workflow:

1. /cm-start [objective]: Start work. The system will automatically initialize the OpenSpec structure (openspec/changes/[objective]/), break down tasks into tasks.md and sync with cm-tasks.json, launch the tracking interface, and autonomously use CM skills to complete them.
2. /cm-dashboard: Open the visual tracking Dashboard in browser (shows Kanban board, reasoning log, and progress).
3. /cm-status: View quick progress summary in Terminal.

💡 Activation Guide by Use Cases

There are 2 ways to use CodyMaster: Fully autonomous (Via Workflows) or Manual skill activation (Via Prompting).

1. Build New Feature / New Project (Autonomous)

Best way to delegate complete work packages.

• Command: /cm-start "Build user management feature with list screen and CRUD form"
• Implicit flow: Planning → create Task JSON → sub-agents continuously run cm-tdd and cm-quality-gate for each task until done.

2. Fix Production Bug (Manual)

Bugs need close supervision and AI should not blindly change too much code.

• Step 1: Activate cm-debugging to find Root Cause.
• Step 2: Activate cm-tdd to write test reproducing the bug and fix it.
• Step 3: Activate cm-safe-deploy to ship code safely.

3. Setup New Project From Scratch

Establish a solid foundation to avoid technical debt later.

• Command: "Use cm-identity-guard to ensure correct account, then run cm-project-bootstrap to setup a new Next.js project."

4. Batch Multi-Language Translation

Tedious work that's error-prone if AI loses focus.

• Command: "Use cm-safe-i18n to extract all hardcoded text in /components directory to vi.json and en.json files."

9 Golden Rules

1. Identity First: Verify account (cm-identity-guard) before push/deploy.
2. Design Before Code: Always have an approved plan before typing.
3. i18n Day 0: Always consider multi-language from the brainstorm step.
4. Test Before Code: RED → GREEN → REFACTOR. No exceptions (cm-tdd).
5. Evidence Over Claims: Only trust terminal/test results output, not AI "saying" it's done.
6. Deploy via Gates: 8 gates must pass sequentially. Any gate fails = STOP (cm-safe-deploy).
7. Safe Secrets: Never commit secrets. Pre-commit hooks protect every push (cm-safe-deploy).
8. Parallel Power: Use parallel execution for i18n or multi-bug fixes (cm-execution).
9. Working Memory: Read CONTINUITY.md at session start, update at session end (cm-continuity).