Codymaster cm-how-it-work

Complete guide to vibe coding with the CodyMaster skill kit — from idea to deploy. Covers the full workflow, skills used at each phase, and common use cases. Read this first if you are new; reference it whenever you're unsure which skill to invoke.

install

source · Clone the upstream repo

git clone https://github.com/tody-agent/codymaster

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/tody-agent/codymaster "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/cm-how-it-work" ~/.claude/skills/tody-agent-codymaster-cm-how-it-work && rm -rf "$T"

manifest: skills/cm-how-it-work/SKILL.md

source content

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-git-worktrees
```
  : 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

Skill	Primary Function
`cm-tdd`	Strict Red-Green-Refactor TDD — no code without failing test first.
`cm-debugging`	Systematic 5-phase error investigation (root cause first).
`cm-quality-gate`	6-gate verification: static analysis → blind review → ship.
`cm-test-gate`	Setup 4-layer test infrastructure (unit → integration → e2e → security).
`cm-code-review`	Manage PR lifecycle: request → receive feedback → complete branch.
`cm-codeintell`	AST knowledge graph + architecture diagrams + smart context (30% fewer tokens).

⚙️ Operations

Skill	Primary Function
`cm-safe-deploy`	Multi-gate deploy pipeline with rollback strategy.
`cm-identity-guard`	Verify account before push/deploy to prevent wrong-project incidents.
`cm-git-worktrees`	Isolate feature work in separate worktrees — no state mixing.
`cm-terminal`	Safe terminal execution with progress logging and error capture.
`cm-secret-shield`	Defense-in-depth: pre-commit hooks, repo scanning, token lifecycle.
`cm-safe-i18n`	Safe multi-language management with multi-pass batching and 8-gate audit.

🎨 Product

Skill	Primary Function
`cm-project-bootstrap`	Full project setup: design system → CI → staging → deploy from Day 0.
`cm-brainstorm-idea`	Strategic analysis gate: 9 Windows + Double Diamond → 2-3 qualified options.
`cm-planning`	Brainstorm intent → write implementation plan → coordinate execution.
`cm-ux-master`	48 UX Laws + 37 Design Tests + Figma/Stitch + BM25 semantic design search.
`cm-ui-preview`	Live UI concept generation via Google Stitch or Pencil MCP.
`cm-dockit`	Generate complete knowledge bases, SOPs, and API docs from codebase.
`cm-readit`	Web audio engine: TTS reader, MP3 audio player, Voice CRO trigger system.
`cm-jtbd`	JTBD customer discovery: Switch Interview → Canvas → Opportunity Scoring.

📈 Growth

Skill	Primary Function
`cm-content-factory`	Self-learning content engine: research → generate → audit → deploy.
`cm-ads-tracker`	Conversion tracking setup: GTM, Meta CAPI, TikTok, Google Ads.
`cm-cro-methodology`	CRO audit: funnel mapping → persuasion assets → A/B test design.

🎯 Orchestration

Skill	Primary Function
`cm-execution`	Execute plans: Manual / Parallel / Subagent / RARV batch modes.
`cm-continuity`	Working memory protocol: read at session start, update at session end.
`cm-skill-mastery`	Meta-skill: when to invoke which skill, how to create new skills.
`cm-skill-chain`	Compose skills into automated multi-step pipelines (5 built-in chains).
`cm-skill-index`	Progressive disclosure index — 90% token savings on skill discovery.
`cm-deep-search`	Semantic search via qmd for large codebases (>200 src / >50 docs files).
`cm-notebooklm`	Cloud Brain sync — cross-machine knowledge persistence via NotebookLM.
`cm-how-it-work`	Full vibe coding guide — phases, skills per phase, use cases.

🖥️ Workflow Commands

Skill	Primary Function
`cm-start`	Orchestrate full workflow from objective to production code.
`cm-dashboard`	Render Kanban board from cm-tasks.json — visual status overview.
`cm-status`	Ultra-concise 1-2 sentence progress summary (what's done, what's next).

🚀 Autonomous Workflow System

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

How to Use the Workflow:

/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.
/cm-dashboard
: Open the visual tracking Dashboard in browser (shows Kanban board, reasoning log, and progress).
/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

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