Using the Jobs-to-be-Done Framework to Direct AI Agents

As a Product Manager, you’ve likely experienced the “Prompt Paradox.” You describe a feature to an AI agent—“Build me a sleek, modern dashboard for tracking sales”—and the agent delivers exactly what you asked for: a sleek, modern dashboard that is utterly useless for your users. It has the wrong charts, the wrong filters, and it fails to solve the actual anxiety your users feel when they open the app on a Monday morning.

In the era of Vibe Coding, where the barrier between “idea” and “implementation” is shrinking to a few lines of natural language, the role of the PM is shifting. You are no longer just a requirement-gatherer; you are an Intent Architect. To succeed, you need a framework that translates human messiness into machine-executable clarity.

That framework is Jobs-to-be-Done (JTBD). When applied to AI agents, JTBD moves the conversation from “what the software should do” to “what the user is trying to achieve.” This article will show you how to use JTBD to steer AI agents with surgical precision, ensuring that your “vibe” results in actual value.

Core Concepts: Why AI Agents Need “Jobs,” Not Features

Most AI agents are trained on massive datasets of code and design, but they lack business context. When you give an agent a feature-based instruction, it defaults to the “average” implementation of that feature found in its training data.

JTBD flips this. Based on the theory popularized by Clayton Christensen, it posits that users don’t buy products; they “hire” them to do a job.

The JTBD Formula for AI Direction

To direct an agent effectively, you must move beyond the User Story (“As a user, I want…”) and embrace the Job Statement:

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

When you feed this structure into an AI agent, you provide the “Why” that informs the “How.”

How It Works in Vibe Coding

In a Vibe Coding environment like Todyle, the AI agent (like Cody Master) uses your input to generate not just code, but the logic, UI, and state management. By using JTBD, you provide the agent with a Success Metric.

Instead of saying “Build a search bar,” you say: “When I’m looking for a specific invoice from six months ago and only remember the client’s name, I want a search interface that prioritizes historical accuracy and fuzzy matching, so that I can find the document in under five seconds without knowing the exact ID.”

Now, the agent knows it needs to implement:

Fuzzy search logic.
A date-range filter (to handle the “six months ago” context).
A high-performance indexing strategy (to hit the “under five seconds” outcome).

Interactive & Practical Example: The “Anxious Accountant” Dashboard

Let’s walk through a real-world scenario. Imagine you are building a financial tool. Your “vibe” is “professional and trustworthy,” but we need to ground that in a Job-to-be-Done.

Step 1: Defining the Job

The User: A small business owner. The Situation: It’s 11:00 PM on a Sunday. They need to know if they can afford a new hire on Monday. The Job: “Hire” a dashboard to gain confidence in cash flow.

Step 2: Translating to Agent Instructions

Instead of writing a 10-page PRD, you provide the agent with the following Job Map:

### AGENT INSTRUCTION: JTBD-LED DASHBOARD
**Primary Job:** Provide immediate "safe-to-spend" confidence.

**Contextual Constraints:**
1. **The 'When':** User is stressed, likely on mobile, needs a binary answer (Yes/No).
2. **The 'Motivation':** Avoid overdrafting while wanting to grow the team.
3. **The 'Outcome':** A clear "Available to Spend" figure that accounts for upcoming automated bills.

**Execution Guidance for Cody Master:**
- Prioritize a large, central numeric display.
- Use a "Future-cast" visualization showing the next 30 days of outflows.
- Design a "What-if" toggle: "If I hire someone at $5k/mo, what does my runway look like?"

Step 3: The Resulting Vibe

By directing the agent this way, it won’t just generate a generic bar chart of “Revenue vs. Expenses.” It will create a predictive tool. It might use a library like Recharts to build a trend line, but it will specifically highlight the “Danger Zone” where cash dips below a certain threshold—because you defined the “Motivation” as “avoiding overdrafting.”

Implementing JTBD in your `.pen` (Pencil) Files

When working with design-focused agents using the Pencil MCP, your JTBD statements directly influence the batch_design operations. For instance, if the Job is “Quick Approval on the Go,” the agent will focus on high-contrast hit areas (buttons) and minimal cognitive load.

Example Pencil Instruction:

// Directing the Pencil Agent via JTBD
U("approval_screen", {
  "layout": "centered-single-column",
  "reasoning": "The user's job is to approve or reject a task while walking between meetings. 
                Visual focus must be on the 'Accept' button, with the 'Reject' button 
                recessed to prevent accidental taps."
})

By providing the reasoning based on the user’s physical situation (walking between meetings), the agent makes better design decisions than if you simply asked for an “approval UI.”

Best Practices & Tips for PMs

Directing AI agents is a skill that requires a balance of empathy and logic. Here is how to master it:

1. Avoid “Feature Bloat” by Validating Against the Job

Every time an AI agent suggests a new feature—“Hey, should I add a social sharing button here?”—ask yourself: Does this help the user complete the ‘Hire’? If the job is “Privately manage my taxes,” a social button is a failure, no matter how “sleek” the code is.

2. Define the “Emotional Job”

Users hire products for functional reasons, but also for emotional ones.

Functional: “Calculate my ROI.”
Emotional: “Make me look like a hero in front of my boss.”

Tell your AI agent about the emotional job. “Design the reporting export to be highly visual and ‘slide-ready,’ so the user feels proud when they attach it to an email.” The agent will then prioritize aesthetics and layout over raw data density.

3. Use “Outcome-Based” Prompting

AI agents are excellent at optimization if you give them a target.

Bad Prompt: “Make the checkout faster.”
JTBD Prompt: “The user’s job is to buy this item before their train arrives. Minimize all non-essential fields. If a field isn’t required for the payment to clear, hide it behind an ‘Advanced’ toggle. The outcome is a sub-15 second checkout.”

4. Iterate on the “Job,” Not the “Code”

In Vibe Coding, if the output is wrong, your first instinct might be to fix the code manually. Don’t. Instead, refine the Job Statement. If the UI is too cluttered, tell the agent: “The user is overwhelmed. Their job right now is just to choose ONE path. Remove everything that doesn’t lead to that choice.”

The “Switch” Interview for Agents

In JTBD theory, we study why users “switch” from an old solution to a new one. You can use this to improve your AI’s competitive edge.

Tell your agent: “Our users are currently switching from Excel spreadsheets to this app because Excel is too slow to update. Your job is to make data entry feel ‘instant.’ Use optimistic UI updates and background syncing so the user never sees a loading spinner.”

By defining the Pain Point of the incumbent (Excel’s slowness), the agent understands that the core value proposition is Latency Reduction.

Conclusion: From Managing Tasks to Managing Intent

The future of Product Management in an AI-driven world isn’t about writing JIRA tickets; it’s about Managing Intent.

When you use the Jobs-to-be-Done framework, you are giving your AI agents a “North Star.” You are moving away from being a micromanager of pixels and syntax, and becoming a strategist of outcomes.

The next time you open your Vibe Coding environment, don’t start with a list of features. Start with a human story. Tell the agent who is hiring the app, what situation they are in, and what success looks like for them. You’ll find that the AI doesn’t just code better—it builds products that people actually want to use.

Your Action Plan:

Audit your current prompts: Are they feature-based or job-based?
Write one “Job Statement” for your next feature.
Feed it to Cody Master and watch how the architectural decisions change.
Refine the “Situation”: Add more context (e.g., “the user is in a noisy environment”) to see how the AI adapts the UX.

Mastering the “Job” is the ultimate unlock for the Vibe Coding era. Start hiring your agents for the right reasons today.