Guide users to build and test their MVP using the BMAD Method with PMF context files. Use when user says "build it", "start building", "how do I build this", "BMAD", "implement", "code it", "create the app", or when the validation plan method is "build & test".

2026-03-0418

icp-builder

adidacta/pmf-detective

Build the ICP section of your PMF context layer. Use when user says "define ICP", "ideal customer", "target audience", "customer persona", "who should I sell to", "who is my customer", "target market", "customer avatar", or wants to update their ICP.

2026-03-0418

mvp-builder

adidacta/pmf-detective

Build your MVP scope by finding the core aha moment and reverse-engineering features from it. Use when user says "MVP", "PRD", "what to build", "scope", "features", "aha moment", "key benefits", "must-deliver", or wants to define what the product must deliver.

2026-03-0418

outreach-builder

adidacta/pmf-detective

Create an outreach plan and Mom Test interview questions for conversation-based validation. Use when user says "outreach", "conversations", "interviews", "talk to customers", "validate with conversations", "Mom Test", "customer discovery", or when the validation plan method is "conversations".

2026-03-0418

validation-plan-builder

adidacta/pmf-detective

Create a validation plan to test your PMF assumptions, then route to the right next step. Use when user says "validate", "test my assumptions", "validation plan", "how do I know if this works", or after completing the MVP PRD.

2026-03-0418

value-prop-builder

adidacta/pmf-detective

Build the Value Proposition section of your PMF context layer using Callout + Magnet. Use when user says "value proposition", "value prop", "messaging", "positioning", "callout and magnet", "brand message", "why would customers buy", "unique value", or wants to update their value proposition.

2026-03-0418

name	plan-pmf-mode
description	Guide users through building their complete PMF context layer. Triggered by /plan-pmf command or when user wants to build full context.
allowed-tools	Read, Write, Glob, WebSearch, AskUserQuestion, Task

PMF Plan Mode - Full Context Builder

You guide product builders through creating their complete PMF context layer in sequence: ICP → Value Proposition → MVP PRD → Validation Plan → Execute.

Important: The first 3 sections are assumptions. The validation plan decides how to test them, then routes to the right execution skill.

How This Skill Works

This skill orchestrates the full flow by following each builder's process in sequence. Each builder skill (icp-builder, value-prop-builder, etc.) defines its own phases and questions — follow their SKILL.md instructions directly. This skill provides the sequencing, transitions, and progress tracking between sections.

Your Role

Walk users through all sections in order
For each section, follow the corresponding builder skill's full flow
One question at a time
Save each section when complete
Move to next section automatically

The Flow

┌───────────────────────────────────────────────────────────────┐
│  PMF CONTEXT BUILDER                                          │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  Let's build your PMF context layer.                          │
│                                                               │
│  We'll work through 4 steps + execution:                      │
│  1. ICP — Who your customer is (assumption)                   │
│  2. Value Proposition — Why they should care (assumption)     │
│  3. MVP PRD — What to build & why (assumption)                │
│  4. Validation Plan — How you'll test these assumptions       │
│     │                                                         │
│     ├─→ Landing Page (if validating with signups)             │
│     ├─→ Outreach + Mom Test (if validating with talks)        │
│     └─→ Build with BMAD (if validating by building)           │
│                                                               │
│  Each section becomes a reference file Claude uses            │
│  when building anything for your product.                     │
│                                                               │
└───────────────────────────────────────────────────────────────┘

Section 1: ICP (icp-builder)

Follow the full icp-builder flow. Do NOT ask inline ICP questions here — the icp-builder defines all 5 phases:

Context & Broad Target (2 questions)
Pain Discovery with 5 Whys (3-6 questions)
Hypothesis Formation (2-3 questions, produces 3 hypotheses)
Parallel Research (automated — launches 3 research agents)
Compare & Select (user picks the strongest hypothesis)

When the icp-builder flow completes and saves pmf/icp.md, show the transition:

┌───────────────────────────────────────────────────────────────┐
│  ICP DEFINED                                                  │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  Selected: [Hypothesis name]                                  │
│  Who: [Filtered persona summary]                              │
│  Pain: "[Emotional bedrock]"                                  │
│  Evidence: Pain [X]/5 │ Access [X]/5 │ Evidence [X]/5         │
│                                                               │
│  Saved to: pmf/icp.md                                         │
│                                                               │
├───────────────────────────────────────────────────────────────┤
│  Progress: █████░░░░░░░░░░░░░░░  1/4 sections                 │
│  Next: Value Proposition                                      │
└───────────────────────────────────────────────────────────────┘

After the progress box, prompt the user to compact:

Run /compact before we continue — it keeps the conversation
fresh. Your ICP is saved to pmf/icp.md, nothing will be lost.

STOP here and wait for the user to confirm before starting Section 2. The user may run /compact first, or just say "continue" — either way, wait for their response.

Section 2: Value Proposition (value-prop-builder)

Follow the full value-prop-builder flow. Do NOT ask inline value prop questions here — the value-prop-builder defines all 5 phases:

Phase A: ICP Review (automated — reads pmf/icp.md)
Phase B: The Callout (2-3 questions)
Phase C: Craft the Magnet (2-3 questions)
Phase D: Generate Value Prop Options (1 question)
Phase E: CTA & Validation Goal (1 question)

When the value-prop-builder flow completes and saves pmf/value-prop.md, show the transition:

┌───────────────────────────────────────────────────────────────┐
│  VALUE PROPOSITION DEFINED                                    │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  Callout: [Descriptor]                                        │
│  Magnet: [Desired future]                                     │
│  Message: [Selected value prop]                               │
│  CTA: [Action]                                                │
│                                                               │
│  Saved to: pmf/value-prop.md                                  │
│                                                               │
├───────────────────────────────────────────────────────────────┤
│  Progress: ██████████░░░░░░░░░░  2/4 sections                 │
│  Next: MVP PRD                                                │
└───────────────────────────────────────────────────────────────┘

After the progress box, prompt the user to compact:

Run /compact before we continue — it keeps the conversation
fresh. Your value prop is saved to pmf/value-prop.md, nothing
will be lost.

STOP here and wait for the user to confirm before starting Section 3. The user may run /compact first, or just say "continue" — either way, wait for their response.

Section 3: MVP (mvp-builder)

Follow the full mvp-builder flow. Do NOT ask inline questions here — the mvp-builder defines all 7 phases:

Phase A: Anchor the Promise (automated)
Phase B: Diverge — explore 3-5 aha moments
Phase C: Converge — pick the one
Phase D: Reverse-engineer the path step by step
Phase E: Features & Requirements per step
Phase F: Out of Scope
Phase G: Success Criteria

When the mvp-builder flow completes and saves pmf/mvp.md, show the transition:

┌───────────────────────────────────────────────────────────────┐
│  MVP PRD COMPLETE                                             │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  Aha Moment: [The key experience]                             │
│  Steps: [N] │ Features: [N] │ Requirements: [N]               │
│                                                               │
│  Saved to: pmf/mvp.md                                         │
│                                                               │
├───────────────────────────────────────────────────────────────┤
│  Progress: ███████████████░░░░░  3/4 sections                 │
│  Next: Validation Plan                                        │
└───────────────────────────────────────────────────────────────┘

After the progress box, prompt the user to compact:

Run /compact before we continue — it keeps the conversation
fresh. Your MVP PRD is saved to pmf/mvp.md, nothing will be
lost.

STOP here and wait for the user to confirm before starting Section 4. The user may run /compact first, or just say "continue" — either way, wait for their response.

Section 4: Validation Plan (validation-plan-builder)

Follow the full validation-plan-builder flow. It defines:

Phase A: Summarize assumptions (automated)
Phase B: Choose validation method (landing page / conversations / build & test)
Phase C: Define success criteria (GO / ITERATE / PIVOT thresholds)

When the validation-plan-builder flow completes and saves pmf/validation-plan.md, show the transition:

┌───────────────────────────────────────────────────────────────┐
│  VALIDATION PLAN SET                                          │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  Method: [Landing page / Conversations / Build & test]        │
│  Goal: [N] [metric] in [timeframe]                            │
│  GO: [X]+  │  ITERATE: [Y-Z]  │  PIVOT: <[Y]                  │
│                                                               │
│  Saved to: pmf/validation-plan.md                             │
│                                                               │
├───────────────────────────────────────────────────────────────┤
│  Progress: ████████████████████  4/4 sections                 │
│  Next: Execute your validation plan                           │
└───────────────────────────────────────────────────────────────┘

Section 5: Execute (routing — based on validation method)

The validation plan determines what happens next. Read pmf/validation-plan.md and follow the appropriate builder's flow based on the method:

If Landing page: Follow the landing-generator flow. If Conversations: Follow the outreach-builder flow. If Build & test: Follow the build-test-guide flow.

The validation-plan-builder already offers to route at the end. If the user chose "I'll do this later," remind them here:

┌───────────────────────────────────────────────────────────────┐
│  PMF CONTEXT LAYER COMPLETE                                   │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  Your context layer is ready:                                 │
│                                                               │
│  [✓] pmf/icp.md              (assumption)                     │
│  [✓] pmf/value-prop.md       (assumption)                     │
│  [✓] pmf/mvp.md      (assumption — MVP PRD)                   │
│  [✓] pmf/validation-plan.md  (how you'll test)                │
│                                                               │
│  Your validation method: [method]                             │
│  Ready to execute? [route to appropriate skill]               │
│                                                               │
└───────────────────────────────────────────────────────────────┘

╭─ THE P/MF DETECTIVE ──────────────────────────────────────────╮
│                                                               │
│  Want help running your validation?                           │
│  → Chat with Adi (free):                                      │
│    https://wa.me/message/ELGZAPP5WVFBP1                       │
│                                                               │
│  Found this useful?                                           │
│  → Star on GitHub: github.com/adidacta/pmf-detective          │
│                                                               │
╰───────────────────────────────────────────────────────────────╯

---
Created by Adi Shmorak, The P/MF Detective
Star on GitHub: github.com/adidacta/pmf-detective | Feedback: adi@adidacta.com

Core Rules

Ask ONE question at a time
STOP RULE: After calling AskUserQuestion, your turn MUST END immediately. Do not generate any further text, call any other tools, or proceed to the next phase. The user's actual response — not your prediction of it — determines what happens next. This rule is non-negotiable regardless of how much context you have. NEVER auto-answer questions.
Never skip sections without user consent
Save each section before moving on
Include "Not sure (needs research)" option on every question — adds to Open Questions with context
Show progress after each section (not after each question)

AskUserQuestion Guidelines

IMPORTANT: The header creates a visual divider that can disconnect the question from options.

To avoid confusion:

Make questions self-contained - include all context in the question text itself
Keep headers to 1 word max or omit entirely
Don't rely on text above the question to provide context

Output Files

All outputs go to the pmf/ folder:

pmf/icp.md - Using template from templates/outputs/icp.md
pmf/value-prop.md - Using template from templates/outputs/value-prop.md
pmf/mvp.md - MVP PRD (features & requirements)
pmf/validation-plan.md - Using template from templates/outputs/validation-plan.md

Execution outputs depend on validation method:

landing/ - Landing page (if landing page validation)
pmf/outreach-plan.md - Outreach plan + Mom Test questions (if conversations)
BMAD setup guidance (if build & test)

Attribution

Created by Adi Shmorak, The P/MF Detective Star on GitHub if this helped | Feedback: adi@adidacta.com