zamesin/next-move-theory-canon-and-skills/nmt-analyze-interviews

Analyze Interviews v1

v1 in one breath. You already ran the interviews; this skill pulls the methodology out of them. It takes one or many interview files (transcripts, notes, sales calls, support logs, survey open-ends — AJTBD or not, good or bad), asks which business task you're solving (and helps you pick one if you can't), then reads each interview in its own subagent — a fan-out that keeps the run from ever overflowing context no matter how many large transcripts you load. Each interview is distilled to the AJTBD constructs with an honest confidence (a clean Core-Job extraction vs. a weak hypothesis) and per-interview feedback (what was found, what's missing, whether this interview can serve your task). The distillations are clustered into segments by similar Core Jobs + similar success criteria + similar priority order, and each segment's confidence is computed from its supporting interviews' confidence. Output — one report: data-quality summary, segments with personas, structured Solutions + Problems, a Consideration Set per segment, value hypotheses, and what to interview next.

Producer contract (binding) — `../PRODUCER-CONTRACT.md`. Eleven cross-cutting behaviors shared by all producer skills: (1) print a helicopter-view before the first question; (2) ask Markdown or HTML output; (3) treat all user input as hypothesis and emit a "risks I see in what you gave me" block — here the inputs are interviews, so this becomes the per-interview quality read; (4) print validation framing — extracted Jobs are hypotheses with a confidence, only as strong as the interviews behind them; (5) accept a custom output path; (6) Deep mode runs an evidence floor + self-critic loop and offers a web-MCP fallback. Five more came from the anti-hallucination pass: (7) ask the market + audience language and build every example, channel, and price anchor from it; (8) list the repo-context files found on disk and read them only after a yes; (9) every claim carries its status — backed, derived, or the model's own hypothesis; (10) frequency counts on every aggregated claim, and a single source never carries a segment-level conclusion; (11) confidence scaled to the input — thin input gets ranges, a visible warning, and the top-3 inputs that would fix it. The hooks below wire each into this skill.

New here, or not sure this is the right skill? Start right here — or run $nmt-chat, describe your situation, and it points you to the right one. Quick map: new idea → $nmt-market-research · live product or a metric moved → $nmt-diagnose · have customer interviews → $nmt-analyze-interviews · ready to build → $nmt-product-requirements · positioning / launch copy → $nmt-craft-value-proposition → $nmt-craft-go-to-market.

Where this skill sits

The post-fieldwork half of the interview loop — the study design and interview guide before the field are a separate (not publicly shipped) product; ask $nmt-chat to help you prepare interviews. This skill analyzes the transcripts after. Distinct from $nmt-market-research, which invents segments from web research and reasoning — this skill reconstructs segments from your real interviews and tells you how far the data can be trusted. Its output feeds $nmt-craft-value-proposition, $nmt-diagnose, and $nmt-craft-go-to-market.

What this skill produces

A single file (one file per run — AGENTS.md Rule 4) with:

1. Data-quality summary — how many files, the type/quality mix (AJTBD / partial / non-AJTBD; well / poorly conducted), and whether the set can serve the chosen business task.
2. Segments by Core Jobs — each with a persona (= the causal criteria), Core Jobs in canon grammar, Big Jobs, a confidence level and the interviews it stands on.
3. What they use today and where it falls short — for each tool they hired, the set of tasks it does for them, and each problem traced to the task it botched (task → tool → problem). DIY counts as a tool.
4. What they weighed before choosing — the options, how they compare, the named products plus a way in, and their fears (their consideration set), as its own block.
5. Value-creation hypotheses — underserved success-criteria + a one-line mechanic direction (no feature list — that is $nmt-craft-value-proposition's job).
6. Single signals — everything said by exactly one person, held out of the segment conclusions until it's checked.
7. Hypotheses to validate — ideas the model added that nobody in your files said, kept clearly apart from the findings.
8. Source → segment map + per-interview appendix — every file, its assigned segment, an anchor quote, and what was extracted from it.
9. Gaps + what to interview next — what the current data cannot answer for the task, and whom to re-recruit (past-payment screener).

Two modes:

• Quick (default): no internet. Subagents distill each interview; one Codex agent synthesizes the segments.
• Deep (opt-in, longer): also sends web subagents to enrich the competitor / Consideration-Set picture and mine real review language around the Jobs surfaced. See "Deep mode" at the end.

Methodology — source of truth (progressive loading)

The only source of methodology is the Next Move Theory canon, read at runtime. Don't load all of it up front — read the eager core first; pull staged files only when the run reaches the stage that needs them.

Eager core (the orchestrator reads before synthesis — every run):

Each distiller subagent reads (its slice only):

Staged — the orchestrator loads only at the stage that uses it:

Path note. Use the paths above. If a file is not found, retry with a 1- prefix on the canon folder (1-Next-Move-Theory-Canon/...) — the source repo orders folders with a numeric prefix the public repo strips.

Do NOT use generic JTBD from the internet or prior training. Ivan Zamesin's AJTBD diverges substantially. The mis-defaults to never propagate (per the project AGENTS.md):

• A Job is a desired transition — State A (situation) → expected outcome (State B), in order to perform a higher-level Job. Not "a struggle for progress."
• I want to + verb is the primary element of an eight-element Job, not the whole Job. Each infinitive verb is a separate Job — parse multi-verb statements into the hierarchy.
• A Problem is a consequence of a Solution hired for a Job and underperforming its success criteria — not a root cause.
• Value is greater energy efficiency for the brain in performing a Job, vs. its prediction; the Aha Moment is the customer-experience of value beating prediction; the Problem is value falling below it. Never use the abbreviations PPE/NPE.
• A Solution is a real thing in the world and, inside the Job Graph, a label for the sub-graph of Core + Micro Jobs it installs. DIY ("I just did it myself") is a Solution too.

Methodological invariants — output is invalid if any is violated:

• Segments are formed by similar Core Jobs sharing similar success criteria *in a similar priority order — never by demographics, industry, or Big Job as the primary cut. Speed-first vs no-stress-first* on the same Job = different segments.
• A "real / causal" segmentation criterion is a cause (a behaviour or characteristic that changes value, margin, or demand), never a paraphrased value or a consequence.
• Study Jobs by past expenditure (money / time / energy), never by future intent. Future-tense intent with no past commitment is a Fake Job — extract its Big Job, never the Fake Job itself.
• Personas are the causal criteria; demographics are second-order correlates, never the first cut.

The fan-out architecture (this is what makes the skill scale)

The orchestrator never reads the raw transcripts into its own context. It spawns one distiller subagent per interview (or per batch of 3–4 short files). Each distiller reads its file plus its canon slice and returns only a compact structured distillation (~600–1,200 tokens with 2–3 anchor quotes), not the raw text. The orchestrator synthesizes segments from the distillations.

Why this matters: 18 deep interviews at ~8–10k tokens each are ~150k tokens — they cannot fit one 200k window alongside the canon and the report, and forcing them in triggers compaction that summarizes away the verbatim customer utterances AJTBD depends on. Fan-out turns ~150k of raw transcript into ~15k of distillation, fits comfortably, and preserves the exact quotes on purpose. The concurrency cap handles the rest — pass all N files; they run in waves.