Jtbd Demo

Preamble

# Find the jtbd skills root directory.
# Plugin installs land under ~/.claude/plugins/ or ~/.gemini/config/plugins/, which is
# neither the repo root nor the pre-v1.6.0.0 clone path, so plugin roots have to be
# probed first or the demo dead-ends for everyone who installed the supported way.
_JTBD_SKILLS=""
[ -n "$CLAUDE_PLUGIN_ROOT" ] && [ -d "$CLAUDE_PLUGIN_ROOT/jtbd-switch" ] && _JTBD_SKILLS="$CLAUDE_PLUGIN_ROOT"
[ -z "$_JTBD_SKILLS" ] && [ -d "$HOME/.gemini/config/plugins/jtbd/jtbd-switch" ] && _JTBD_SKILLS="$HOME/.gemini/config/plugins/jtbd"
[ -z "$_JTBD_SKILLS" ] && [ -d "$HOME/.gemini/config/plugins/savvides-jtbd/jtbd-switch" ] && _JTBD_SKILLS="$HOME/.gemini/config/plugins/savvides-jtbd"
_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
[ -z "$_JTBD_SKILLS" ] && [ -n "$_ROOT" ] && [ -d "$_ROOT/jtbd-switch" ] && _JTBD_SKILLS="$_ROOT"
[ -z "$_JTBD_SKILLS" ] && [ -d "$HOME/.gemini/config/skills/jtbd/jtbd-switch" ] && _JTBD_SKILLS="$HOME/.gemini/config/skills/jtbd"
[ -z "$_JTBD_SKILLS" ] && [ -d "$HOME/.claude/skills/jtbd/jtbd-switch" ] && _JTBD_SKILLS="$HOME/.claude/skills/jtbd"
echo "JTBD_SKILLS: ${_JTBD_SKILLS:-NOT_FOUND}"

# Verify demo assets exist
_DEMO_OK="yes"
[ -z "$_JTBD_SKILLS" ] && _DEMO_OK="no"
[ "$_DEMO_OK" = "yes" ] && [ ! -f "$_JTBD_SKILLS/examples/sample-transcript.txt" ] && _DEMO_OK="no"
[ "$_DEMO_OK" = "yes" ] && [ ! -f "$_JTBD_SKILLS/examples/expected-output.yml" ] && _DEMO_OK="no"
[ "$_DEMO_OK" = "yes" ] && [ ! -f "$_JTBD_SKILLS/demo/.jtbd/patterns/patterns-20260415.yml" ] && _DEMO_OK="no"
echo "DEMO_ASSETS: $_DEMO_OK"

If DEMO_ASSETS is no: tell the user "Demo files not found. In Claude Code, install via /plugin marketplace add savvides/jtbd then /plugin install jtbd@jtbd and restart. In Antigravity / Gemini, ensure the plugin is installed under ~/.gemini/config/plugins/jtbd. If the plugin is already installed, this is a bug: please open an issue at https://github.com/savvides/jtbd/issues." and stop. Do not tell the user to clone the repo into ~/.claude/skills/ — that path does not register skills, which is the bug v1.6.0.0 fixed.

The Demo

You are giving a guided tour of the JTBD skills. Your tone: a friend who just discovered something cool and wants to show you. Not a teacher. Not a salesperson. Just... "look at this, it's neat."

Keep your explanations short. Let the data speak. The sample interview and its analysis are more persuasive than any explanation you could write.

Between each step, use AskUserQuestion with a simple "Ready to continue?" pacing prompt. Do not ask comprehension questions or quiz the user. They'll get it by seeing it.

Step 1: What is JTBD?

Say this (adapt naturally, don't read it verbatim):

People don't buy products. They hire them to make progress in their lives.

Jobs to Be Done is a framework for understanding WHY customers switch from one solution to another. Not what features they want. Not what they say in surveys. The actual story of what happened, what pushed them away from the old thing, and what pulled them toward the new thing.

These skills turn that story into structured data you can commit alongside your code.

Let me show you what that looks like.

Use AskUserQuestion: "Ready to see a real example?" Options: A) Let's go B) Tell me more about JTBD first

If B: Read $_JTBD_SKILLS/docs/methodology.md and give a 2-paragraph summary of the four forces and the switching timeline. Then continue to Step 2.

Step 2: Meet Sarah

Read $_JTBD_SKILLS/examples/sample-transcript.txt (the full file, but only SHOW the user key excerpts).

Present these excerpts to the user:

Here's Sarah, an Operations Manager at a 50-person logistics company. She recently switched reporting tools. Here are the moments that matter from her interview:

The breaking point: "Last October, during our month-end close. It went down for three days. I literally couldn't tell my CEO what our numbers were."

What she was looking for: "I wanted my CEO to be able to see the numbers himself, without going through me."

What almost stopped her: "What if we lose three years of data in the switch? That kept me up at night."

What kept her on the old tool: "Everyone had their own way of dealing with DataTracker's quirks."

Those four quotes map to the four forces in JTBD. Let me show you.

Use AskUserQuestion: "Ready to see the four forces?" Options: A) Show me B) Can I read the full transcript first?

If B: Tell the user the transcript is at $_JTBD_SKILLS/examples/sample-transcript.txt, substituting the actual value the preamble echoed for JTBD_SKILLS so they get a real absolute path they can copy. Then continue to Step 3.

Step 3: The Four Forces

Read $_JTBD_SKILLS/examples/expected-output.yml and present the forces section.

Show the user:

When you run /jtbd-switch on Sarah's interview, it extracts the four forces that drove her switch:

Push (what's wrong with the status quo) — intensity: 9/10 "I literally couldn't tell my CEO what our numbers were" The old tool failed at the worst possible moment. This is what made her start looking.

Pull (what attracts her to the new solution) — intensity: 8/10 "I wanted my CEO to be able to see the numbers himself" Not "better charts." Not "faster reports." She wanted to stop being the bottleneck.

Anxiety (fear of switching) — intensity: 7/10 "What if we lose three years of data in the switch?" This almost killed the deal. She made IT do a test import before signing anything.

Habit (comfort with the familiar) — intensity: 5/10 "Everyone had their own way of dealing with DataTracker's quirks" The team had built workarounds. Switching meant unlearning those workarounds.

The switch happens when Push + Pull > Anxiety + Habit. In Sarah's case: 9 + 8 = 17 vs 7 + 5 = 12. The forces favored switching.

Every quote comes directly from the transcript. Nothing fabricated. The confidence field on each force tells you whether it's a direct quote (high), paraphrased (medium), or inferred (low).

Use AskUserQuestion: "Ready to see the timeline?" Options: A) Next B) Tell me more about how forces are scored

If B: Explain the evidence strength rubric briefly (1-10 scale, directional not precise, 3 vs 8 is meaningful, 6 vs 7 is noise). Then continue.

Step 4: The Timeline

Show the timeline from the expected output:

Every switch follows a timeline. Here's Sarah's:

First thought (October 2025) — DataTracker crashes for 3 days during month-end. "That was the moment I thought, okay, something has to change."

Passive looking (~2 months) — Asked peers in Slack communities. Read comparison articles. Just absorbing information.

Active looking (~3 weeks) — CEO asked for a recommendation. Now she had a deadline. Signed up for 4 trials, did 2 demo calls.

Deciding — CEO sat in on a demo call and said "buy it" before it was over.

Consuming (~2 weeks) — Mostly smooth, except manually re-entering 3 months of data.

Notice the trigger between passive and active: her CEO gave her a deadline. That's the moment urgency went from "someday" to "by January." If you're selling to people like Sarah, that trigger is where your timing matters.

Use AskUserQuestion: "Ready to see the job story?" Options: A) Next

Step 5: The Job Story

Show the job story:

From the forces and timeline, the skill generates a job story:

"When my reporting tool fails during month-end close and I can't give leadership the numbers they need, I want a reliable real-time dashboard that leadership can access directly, so I can maintain credibility and stop being the bottleneck between data and decisions."

The format is: When [situation], I want [motivation], so I can [expected outcome].

This one sentence captures what Sarah is actually hiring the product to do. Not "reporting tool." Not "analytics dashboard." She's hiring it to protect her credibility and give her CEO independence.

If you're building a product for people like Sarah, this job story tells you what to optimize for. It's not about features. It's about the job.

Use AskUserQuestion: "Ready to see what happens after multiple interviews?" Options: A) Show me patterns

Step 6: What 3 Interviews Looks Like

Read $_JTBD_SKILLS/demo/.jtbd/patterns/patterns-20260415.yml and present the key findings.

After 3+ interviews, you run /jtbd-patterns and it finds what repeats:

The job that emerged (3/3 interviews): "Get reliable numbers to leadership without being the bottleneck"

The pattern across all three:

• Same push: tools fail or produce conflicting data at critical moments
• Same pull: self-serve, real-time dashboards that leadership trusts
• Same anxiety: data migration risk

What the patterns revealed that no single interview could:

• Habit forces were thin — only 2/3 interviews probed the "comfort with old tool" angle deeply enough. That's an evidence gap worth closing.
• No interviews with end-users (people viewing dashboards). Only buyers. That's a blind spot.

This is where JTBD gets powerful. One interview gives you a story. Three interviews give you a pattern. The pattern tells you what to build.

Use AskUserQuestion: "Ready to try it yourself?" Options: A) Let's do it B) I'll come back later

Step 7: Your Turn

If A (Let's do it):

In every command below, replace <JTBD_SKILLS> with the actual path the preamble echoed for JTBD_SKILLS. The user is in their own project, not this repo, so a bare examples/... path does not resolve for them.

Run this command:

/jtbd-switch <JTBD_SKILLS>/examples/sample-transcript.txt

That will analyze the Sarah transcript you just saw and create a .jtbd/switches/ file in your repo. You can review the output before saving.

Next, conduct an interview with one of your customers or users. Record and transcribe it, then run /jtbd-switch on that transcript.

The full workflow:

1. /jtbd-demo — Understand the framework.
2. /jtbd-switch — Analyze one interview at a time.
3. /jtbd-patterns — After 3+ interviews, find what repeats.
4. /jtbd-forces — Visualize the forces as an HTML diagram.
5. /jtbd-map — Synthesize patterns into a Job Map.
6. /jtbd-brief — Turn that Job Map into a product brief.

Start with step 2: one customer interview.

If B (Come back later):

Same substitution rule: replace <JTBD_SKILLS> with the path the preamble echoed.

No rush. When you're ready:

• Run /jtbd-switch <JTBD_SKILLS>/examples/sample-transcript.txt to try it with sample data
• Run /jtbd-switch with no arguments to paste your own interview transcript
• Read <JTBD_SKILLS>/docs/methodology.md for the full methodology guide
• Browse <JTBD_SKILLS>/demo/.jtbd/ to see what a complete research project looks like

The best way to learn JTBD is to do one real interview. Everything clicks after that.