Mastering `cm-jtbd`: The Complete Guide

In the high-velocity world of Vibe Coding, speed is often treated as the ultimate metric. We celebrate the ability to move from a napkin sketch to a deployed React component in under five minutes. But this speed carries a hidden, often fatal, risk: the “Feature Factory” trap. You can ship a dozen perfectly polished, AI-generated features every day and still watch your user retention metrics plummet. Why? Because you are building things people don’t actually need. You are coding the how without ever truly understanding the why.

This is where cm-jtbd enters the frame. As a core pillar of the Cody Master (CM) toolkit, cm-jtbd is not just another documentation template. It is a strategic discovery engine designed to ground your Vibe Coding in the rigorous reality of Jobs-To-Be-Done (JTBD) theory. It transforms your CLI from a mere code generator into a high-level product architect. This guide will walk you through exactly how to master this skill to ensure that every line of code you “vibe” into existence serves a deep, validated human need.

The Problem: The “Ghost Town” Feature Syndrome

Every developer has been there. You have a “vibe” for a cool new dashboard widget. You use an agent to scaffold the backend, generate the shadcn/ui components, and wire up the state management. It looks beautiful. It’s technically flawless. You launch it—and no one uses it.

This happens because most development begins with a solution-first mindset. We start with the technology (AI, LLMs, Vector DBs) and look for a problem to solve. cm-jtbd forces a problem-first pivot. Based on the framework popularized by Clayton Christensen, JTBD theory posits that customers don’t “buy” products; they “hire” them to do a specific job. If you don’t know what that job is, your code is just expensive noise.

cm-jtbd solves this by automating the discovery of the functional, social, and emotional dimensions of your user’s goals before you even touch a package.json.

Core Concepts: How `cm-jtbd` Thinks

To use cm-jtbd effectively, you need to understand the three layers of a “Job” that the skill investigates. When you trigger the skill, the Cody Master agent doesn’t just look for a feature list; it builds a multidimensional map of the user’s struggle.

1. The Functional Job

This is the most obvious layer. It’s the task the user needs to complete.

Example: “I need to generate an invoice.”
Vibe Coding Trap: Building a complex invoicing system with 50 templates when the user just needs a PDF link.

2. The Emotional Job

This is how the user wants to feel or avoid feeling while doing the task.

Example: “I want to feel professional and organized,” or “I want to avoid the anxiety of a tax audit.”
Vibe Coding Insight: Your UI should emphasize “Security” and “Clarity” over “Flashy Animations.”

This is how the user wants to be perceived by others.

Example: “I want my clients to think I’m a high-end agency, not a freelancer working from a couch.”
Vibe Coding Insight: The generated email templates must be elite, using formal language and sophisticated design tokens.

The cm-jtbd skill uses these dimensions to produce a JTBD Canvas. This canvas becomes the “source of truth” for all subsequent AI coding tasks. When you later ask an agent to “build the dashboard,” the agent refers back to the JTBD Canvas to decide which features are essential and which are distractions.

How It Works: The Workflow

The cm-jtbd skill follows a disciplined, multi-step process. You don’t just get a wall of text; you get a validated strategic plan.

Step 1: Context Ingestion

When you run cm-jtbd with a prompt, the agent first scans your existing product.md or DESIGN.md files (using tools like vexor or grep_search). It looks for gaps in your understanding. If your documentation is all about “How the API works” and nothing about “Who is the user,” it will flag this as a risk.

Step 2: The “Switch” Analysis

The skill simulates a “Switch Interview”—a technique used to understand why users switch from an old solution (like Excel) to a new one (your app). It analyzes:

The Push: What is making the current situation unbearable?
The Pull: What is attractive about your proposed solution?
The Anxiety: What is stopping them from making the change?
The Inertia: What old habits are keeping them stuck?

Step 3: Synthesis & Artifact Creation

The agent then generates a jtbd.md file (or updates your continuity logs) with a structured Job Statement:

“When [Situation], I want to [Motivation], so that I can [Expected Outcome].”

Interactive Example: From Vague Vibe to Validated Job

Let’s look at a real-world scenario. Suppose you want to build a “Micro-SaaS for automated LinkedIn comment suggestions.”

The Vague Vibe:

“I want to build a tool that uses AI to suggest smart comments for LinkedIn posts so people can grow their accounts faster.”

If you start coding now, you’ll probably build a generic Chrome extension with a “Generate Comment” button. You’ll fight with UI styling and API rate limits.

The cm-jtbd Intervention: Run the command: cm-jtbd "Analyze the job for a LinkedIn engagement tool for busy founders."

The Skill’s Output (Summarized): The agent will return a canvas that looks like this:

Main Job: Maintain professional visibility without sacrificing deep work time.
Situation: A founder is in between meetings, scrolling LinkedIn for 5 minutes.
Functional Need: High-quality, non-generic responses that don’t look like “AI-slop.”
Emotional Need: Relieving the guilt of being “invisible” in the industry conversation.
Social Need: Being seen as a “thought leader” who provides actual value, not just a “Great post!” bot.

The Pivot: Because of this cm-jtbd analysis, your “vibe” changes. You realize that a “Generate Comment” button is actually bad for the social job—it looks fake. Instead, you decide to build a “Tone-Matched Context Summarizer” that highlights the most relevant part of a post and suggests a counter-argument or a supporting statistic.

You just saved yourself three weeks of building a product no one would “hire.”

Best Practices & Tips

To get the most out of cm-jtbd, follow these industry-standard patterns:

1. Trigger Early, Trigger Often

Don’t wait until you’re stuck. Run cm-jtbd the moment a new feature idea enters your head. It is the cheapest form of prototyping. It costs zero tokens to decide not to build something.

2. Combine with `cm-brainstorm-idea`

Use cm-jtbd to find the problem, then use cm-brainstorm-idea to explore 2-3 different technical ways to solve that specific job. This “Double Diamond” approach (Discovery -> Definition -> Development) is the secret to elite product engineering.

3. Use the “Five Whys”

If the initial JTBD output feels superficial, prompt the agent: “That’s too functional. Use the ‘Five Whys’ technique to dig into the emotional job for this persona.” This forces the LLM to move past the surface-level “I need a tool” to the deeper “I am afraid of failing.”

4. Update Your Continuity

The cm-jtbd output should be saved into your CONTINUITY.md. This ensures that every other sub-agent you hire for the project (the frontend-developer, the backend-architect) is “indoctrinated” into the user’s struggle. When the frontend agent sees the emotional job is “Anxiety Reduction,” it will automatically suggest a more soothing color palette and clearer error messages.

5. Validate with “Anti-Jobs”

Ask the agent: “What is a job that this tool is NOT hired for?” This helps define the boundaries of your MVP. For our LinkedIn tool, it might be “This is NOT for people looking for a job.” This allows you to skip building “Resume Integration” and stay focused on the “Busy Founder” persona.

The Vibe Coding Philosophy: Meaningful Speed

Vibe Coding is often criticized as being “slapdash” or “unstructured.” By integrating cm-jtbd into your workflow, you prove the critics wrong. You are not just coding fast; you are aiming precisely.

The cm-jtbd skill represents the “Master” in Cody Master. It’s the difference between a junior dev who follows instructions and a senior architect who questions them. It ensures that when you finally say “Ship it,” you aren’t just shipping code—you’re shipping a solution to a problem that actually matters.

Conclusion

Mastering cm-jtbd is about developing a “Product Sense” that matches your “Coding Speed.” In the Todyle ecosystem, we don’t just value the ability to write a loop; we value the wisdom to know if that loop needs to exist.

Next time you feel the urge to start a new project, resist the temptation to run npm init immediately. Instead, open your terminal and start with the Job. Define the struggle, map the motivation, and capture the expected outcome. Use cm-jtbd to build the foundation, and then—and only then—let the vibes take over. Your users (and your churn rate) will thank you.

Mastering cm-jtbd: The Complete Guide