The Ultimate CodyMaster Skill Index: Which Skill to Use When

You’re standing at the threshold of a new project. Your IDE is open, your terminal is blinking, and the possibilities are endless. You’ve heard the legends of “Vibe Coding”—the ability to manifest complex applications through high-level intent and AI orchestration. You’ve installed CodyMaster, the elite toolkit designed to turn these legends into your daily reality. But then, it hits you: the Skill Choice Paralysis.

With dozens of specialized skills at your fingertips—ranging from cm-planning to cm-quality-gate and cm-jtbd—the internal monologue begins. “Do I start with a plan, or should I brainstorm first? Is it too early for a quality gate? How do I make sure the AI doesn’t forget what we did ten minutes ago?”

If you’ve ever felt overwhelmed by the sheer power of your own tools, you are not alone. This is the “Vibe Coder’s Paradox”: having the power to do anything, but not knowing which lever to pull first. This guide is your map. We are going to deconstruct the CodyMaster Skill Index, categorized by the specific “Job To Be Done” (JTBD), so you can stop wondering and start building.

Core Concepts: The “Skill Layer Cake”

Before we dive into the specific skills, we need to understand the philosophy of CodyMaster. In traditional coding, you are the mechanic, the architect, and the inspector all at once. In Vibe Coding with CodyMaster, you are the Orchestrator.

Skills are not just “scripts”; they are cognitive modules. Each skill encapsulates a specific set of professional standards, mental models (like TRIZ or Jobs-To-Be-Done), and execution patterns. When you invoke a skill, you aren’t just running a command; you are hiring a “Senior AI Specialist” to handle one specific layer of your project.

We can visualize these skills as a “Layer Cake”:

The Continuity Layer (Foundation): The memory and identity of your project.
The Strategy Layer (Planning): The “Think Before You Ink” phase.
The Execution Layer (Action): The actual writing of code and building of features.
The Validation Layer (Safety): Ensuring everything works and stays secure.

1. The Continuity Layer: The Heartbeat of Your Session

The biggest failure in AI-assisted development is “Context Drift.” The AI forgets the architectural decisions you made in Turn 1 by the time you reach Turn 10.

`cm-continuity`: Your Working Memory

When to use it: Every. Single. Time. cm-continuity is the most important skill in the index. It manages a CONTINUITY.md file that tracks your current progress, known bugs, and “Lessons Learned.”

The Problem: The AI repeats a mistake it already made.
The Solution: cm-continuity captures that mistake as a “Never Do This Again” rule, ensuring the session stays on track.

`cm-identity-guard`: The Safety Lock

When to use it: Before any git push or deploy. If you work on multiple projects (e.g., a personal side project and a corporate repo), cm-identity-guard ensures you don’t accidentally leak secrets or use the wrong GitHub identity.

2. The Strategy Layer: High-Leverage Thinking

Beginners often make the mistake of jumping straight into cm-execution. Professional Vibe Coders spend 60% of their time in the Strategy Layer.

`cm-brainstorm-idea`: The Innovation Engine

When to use it: When you have a vague idea but no concrete feature list. This skill uses the Double Diamond design process and TRIZ (Theory of Inventive Problem Solving) to explore your idea.

Example: “I want to add a chat feature.” cm-brainstorm-idea will ask if it should be real-time, threaded, or AI-moderated, exploring the trade-offs before you write a single line of CSS.

`cm-jtbd`: Finding the “Why”

When to use it: When you need to ensure people will actually use what you build. Jobs-To-Be-Done (JTBD) is a framework that asks: “What job is the user hiring this feature to do?”

The Problem: Building a “Notification Center” that just annoys users.
The Solution: Use cm-jtbd to realize the user “hires” notifications to “feel secure that they haven’t missed an urgent update.” This shifts your design from “show everything” to “show what matters.”

`cm-planning`: The Blueprint

When to use it: After brainstorming, before coding. cm-planning generates a structured, atomic checklist. It forces the AI to define its “Implementation Strategy” and “Verification Criteria” upfront. Never skip this. A project without a plan is just a series of expensive mistakes.

3. The Execution Layer: Turning Vibe into Code

This is where the magic happens. Once the strategy is locked, these skills handle the heavy lifting.

`cm-execution`: The Workhorse

When to use it: To execute the tasks generated by cm-planning. This skill knows how to coordinate sub-agents. It can handle batch refactors or focus on a single, surgical fix. It is the “hands” of your operation.

`cm-project-bootstrap`: The Day Zero Specialist

When to use it: When you are starting a brand-new repository. Instead of manually running npm init and setting up folders, cm-project-bootstrap sets up a professional-grade foundation: design systems, test gates, i18n (internationalization) support, and SEO foundations from minute one.

4. The Validation Layer: The Professional Standard

Shipping code that “seems to work” is the hallmark of an amateur. Shipping code that is verified is the hallmark of a CodyMaster.

`cm-quality-gate`: The Ultimate Protector

When to use it: Before you claim a task is “Done.” This skill is a “No-Pass” zone. It checks if tests are passing, if the UI is responsive, and if the code follows the project’s style guides.

The Mantra: “No evidence, no completion.” If you can’t prove it works with a test or a screenshot, cm-quality-gate will reject the work.

`cm-debugging`: The Detective

When to use it: When something breaks (and it will). Instead of guessing, cm-debugging takes a systematic approach. It looks at logs, traces the state, and identifies the root cause before proposing a fix. It prevents the “whack-a-mole” style of bug fixing where one fix breaks three other things.

Interactive Example: The “Vibe-to-Vessel” Workflow

Let’s walk through a practical scenario. Imagine you want to build a “Daily Gratitude Journal” app that uses AI to summarize your mood.

Step 1: Initialization

You start the session. You don’t just type “build me a journal.” You invoke the foundation.

Action: Call cm-start and cm-continuity. Result: A CONTINUITY.md file is created. Your “Working Memory” is now active.

Step 2: Strategic Discovery

You think you know what the app should look like, but you want it to be great.

Action: Call cm-jtbd. Discovery: You realize users don’t just want a “text box.” They hire a journal to “find patterns in their happiness.” Pivot: You decide to add a “Mood Trend” chart instead of just a list of entries.

Step 3: The Blueprint

Now you define exactly what needs to be built.

Action: Call cm-planning. Result: You get a 5-step plan: 1. Setup Database, 2. Build Entry Form, 3. Integrate AI Summary, 4. Build Trend Chart, 5. Deployment.

Step 4: The Build

You let the agents work.

Action: Call cm-execution for Step 1 and 2. Pro Tip: Use the Pencil MCP integration here to “Vibe” the UI design before writing the React components.

Step 5: The Audit

You’ve finished the “Trend Chart.” It looks good on your screen.

Action: Call cm-quality-gate. Failure: The gate identifies that the chart isn’t readable on mobile devices. Fix: You adjust the CSS, run the gate again, and it passes.

Best Practices & Tips for Success

To truly master the CodyMaster Skill Index, you need to move beyond knowing what the tools are and start knowing how to wield them.

Respect the Chain: Do not skip from cm-start to cm-execution. The Strategy Layer (Planning/Brainstorming) is what prevents technical debt. If you skip the strategy, you’ll spend twice as long in cm-debugging later.
Keep Continuity Clean: Periodically check your CONTINUITY.md. If it gets too cluttered, ask the AI to “summarize and archive old context.” A clean memory leads to a fast AI.
The “Surgical” Mindset: When using cm-execution, try to work in small, atomic batches. Don’t ask it to “build the whole app.” Ask it to “implement the authentication logic according to the plan.”
Trust the Gates: When cm-quality-gate tells you something is wrong, don’t argue with it. It is enforcing the standards you set. Use that feedback to improve the “Vibe” of your project.
Document as You Go: Use cm-dockit at the end of every major feature. It will analyze your code and generate professional API references and user guides. This makes your project “LLM-readable,” meaning other AI agents can help you better in the future.

Conclusion: From Coder to Orchestrator

The transition from traditional coding to Vibe Coding is a shift in identity. You are no longer just the person typing the characters; you are the Director of an Elite Engineering Team.

The CodyMaster Skill Index is your roster of specialists.

Need a visionary? Call cm-brainstorm-idea.
Need a drill sergeant? Call cm-quality-gate.
Need a historian? Call cm-continuity.

By understanding “Which Skill to Use When,” you remove the friction between your imagination and your implementation. You stop fighting the tool and start flowing with it.

Your next great project isn’t hidden in a library or a framework—it’s waiting for you to pick up the right skill and start the “Vibe.” Go build something incredible.