The Data Flow of the JTBD Discovery Framework

In the era of Vibe Coding, the distance between an idea and a deployed application has shrunk to a few conversational turns. However, this velocity introduces a dangerous paradox: the faster we can build, the faster we can build the wrong thing. Traditional product management often fails in the high-entropy environment of autonomous agents because it relies on static documents that AI cannot deeply “feel” or iterate upon.

To bridge this gap, the Jobs-To-Be-Done (JTBD) Discovery Framework serves as the cognitive spine of the Todyle Vibe Coding platform. This isn’t just a marketing theory; it is a rigorous data flow pipeline that transforms raw human intent into high-fidelity, executable specifications. This article deconstructs the advanced data flow of JTBD discovery and explains how it eliminates “semantic drift” in AI-driven development.

1. The Core Problem: Intent Entropy in Vibe Coding

Vibe Coding is often criticized as “vague coding.” When a user tells an agent, “Make me a better dashboard,” the agent lacks the context of why the current one is failing. It might optimize for visual aesthetics (Functional Job) while the user is actually suffering from a lack of “authority signaling” to their stakeholders (Social/Emotional Job).

Without a structured discovery framework, the AI undergoes Intent Entropy. The original vision is diluted through layers of prompt engineering until the final output is a generic hallucination. The JTBD Discovery Framework solves this by capturing “Latent Intent” and converting it into a structured data format—typically a cm-jtbd canvas—that acts as the single source of truth for all subsequent agent actions.

2. The Data Flow Pipeline: From Signal to Spec

The JTBD framework on Todyle operates as a three-stage pipeline: Extraction, Triangulation, and Synthesis.

Stage 1: Raw Signal Extraction

The process begins with the cm-jtbd skill. Instead of asking what the user wants to build, the framework investigates what the user wants to achieve.

Data Input: Unstructured conversational data, existing pain points, and “Switch Interviews” (why the user is leaving their current solution). Processing: The framework categorizes inputs into four distinct job categories:

Functional Jobs: The practical tasks (e.g., “I need to calculate taxes accurately”).
Social Jobs: How the user wants to be perceived (e.g., “I need to look professional to my investors”).
Emotional Jobs: How the user wants to feel (e.g., “I want to feel secure that I won’t get audited”).
Negative Jobs: What the user wants to avoid (e.g., “I don’t want to spend more than 10 minutes on this”).

Stage 2: Semantic Triangulation

Once the jobs are identified, the framework performs a “Desired Outcomes” analysis. This is where we move from qualitative vibes to quantitative metrics.

We use the formula: [Direction] + [Metric] + [Object of Control].

Example: “Minimize (Direction) + the time spent (Metric) + reconciling bank statements (Object).”

This triangulation ensures that the AI agent has a “Success Criterion” that is independent of the implementation. If the agent proposes a feature that doesn’t move the needle on these metrics, the framework rejects the plan during the cm-quality-gate phase.

Stage 3: Specification Synthesis

The final stage of the data flow is the creation of a JTBD_SPEC.md. This file is not meant for humans; it is a “Context Anchor” for the implementation agents. It maps every proposed feature back to a specific Job Statement.

3. Practical Example: Building a High-Stakes Pricing Engine

Let’s look at how this data flow works in a real-world Vibe Coding session. Imagine a founder who wants to build a “Dynamic Pricing Engine” for their SaaS.

Step 1: The `cm-jtbd` Invocation

Instead of jumping to “Create a Python script for pricing,” the architect invokes the JTBD skill.

# JTBD Discovery Output: Pricing Engine
## The Main Job
"When I am scaling my SaaS, I want to automate my pricing adjustments 
so that I can maximize Revenue Per User without manual intervention."

## Desired Outcomes
- Increase Average Contract Value (ACV) by at least 15%.
- Reduce 'Pricing Anxiety' for the sales team by providing data-backed tiers.
- Minimize the time from 'Market Shift' to 'Price Update' to under 2 hours.

Step 2: Mapping Logic to Jobs

The data flow now forces the agent to justify its tech stack. If the agent suggests using a “Basic Cron Job,” the framework checks it against the Emotional Job (Feeling secure/competitive). A simple cron job might be too brittle, so the data flow suggests a Temporal Workflow to ensure durability and auditability—directly addressing the emotional need for “Zero Failure.”

Step 3: Executable Spec Generation

The Framework generates a PLAN.md where every task is tagged with a Job ID.

{
  "task": "Implement Real-time Competitor Scraper",
  "jtbd_ref": "FUNC_JOB_01",
  "success_metric": "Latency < 5 minutes",
  "vibe_check": "Professional/Aggressive"
}

4. Best Practices for Advanced Discovery

To master the data flow of JTBD in Vibe Coding, follow these “Content Mastery” principles:

A. Hunt for the “Job of the Job”

Advanced users know that the first job identified is usually a surface-level functional one. Keep digging until you find the Social Job. If you are building a CLI tool, the functional job is “Running commands.” The social job might be “Becoming the ‘Terminal Wizard’ in the office.” Designing for the social job leads to features like “Customizable Themes” and “Command History Visualization” that a functional-only discovery would miss.

B. Use “Forces of Progress” Modeling

When analyzing the data flow, visualize the four forces acting on the user:

Push: The pain of the current solution.
Pull: The magnetism of the new “Vibe.”
Anxiety: What if the AI breaks my production code?
Habit: “I’ve always done it this way in VS Code.”

Your cm-jtbd output must explicitly address Anxiety and Habit. If the framework doesn’t account for these, the user will eventually revert to old workflows, regardless of how “cool” the new AI features are.

C. Orthogonality in Metrics

Ensure your Outcome Metrics are orthogonal (non-overlapping). If you have two metrics that measure “Speed,” the AI will over-optimize for performance at the expense of “Reliability.” The JTBD data flow should balance competing priorities: Speed vs. Accuracy vs. Cost.

5. How This Solves Real Problems in Vibe Coding

In a traditional development cycle, a developer might spend 40 hours building a feature only to realize the “Vibe” was wrong. In the Todyle ecosystem, the JTBD Discovery Framework acts as a Pre-Ingestion Filter.

Hallucination Prevention: By grounding the agent in specific Job Statements, we limit the “Search Space” for the AI. It no longer tries to build “everything”; it only builds what satisfies the Job.
Autonomous Refactoring: If the agent encounters a bug, it refers back to the JTBD spec. If a fix satisfies the code but breaks the “Social Job” (e.g., making the UI look cluttered), the agent will seek an alternative fix autonomously.
Context Density: It allows for “Long-Term Memory” across sessions. When you return to a project three months later, the CONTINUITY.md file (synced with JTBD) tells you not just what was built, but the intent that drove those decisions.

6. Conclusion: The Future of Intent-Driven Architecture

The Data Flow of the JTBD Discovery Framework is the difference between a toy and a tool. In the world of Vibe Coding, where the cost of generation is near zero, the value of Discrimination—knowing what not to build—becomes the ultimate competitive advantage.

By treating “Intent” as a structured data type that flows through a discovery pipeline, we turn autonomous agents into true partners. We move away from “Prompting” and toward “Orchestrating.” The next time you start a Vibe Coding session, don’t reach for the write_file tool first. Reach for cm-jtbd. Discover the job, map the metrics, and let the data flow define the architecture.

This is how we build software that doesn’t just work—it belongs. High-craft, intent-driven, and perfectly aligned with the human “Vibe” that started it all.