Founder Validation

Founder Validation (Phase 2)

Child of founder. Validation support — owns the assumption ledger, experiment design, interview scripts (Mom Test protocol), browser MCP analytics reading (Envelope D), and evidence capture with user-reported artifacts. The user is the validator. This skill is the infrastructure.

Scope: Validation infrastructure. Designs experiments, drafts scripts, captures user-reported evidence, reads analytics, reviews evidence gaps. Does NOT autonomously validate a business. The user runs the experiments and reports back.

Siblings (parent = founder):

• founder-ideation — Phase 1 — adversarial brainstorm + data grounding
• founder-business-model — Phase 2 — calculator mode unit economics
• founder-sprint — Phase 2 — lean gatekeeper stage machine
• founder-gtm — Phase 3 (deferred) — positioning, distribution, channel selection

Inherited hard rules (from parent founder): HR-1 through HR-11 all apply. Key inherited constraints: no valuation/legal/tax advice (HR-1, HR-2), no LLM-generated TAM (HR-3), kill criteria required on all ideas (HR-4), data citations required (HR-5), founder is pre-execution only (HR-6), venture-brief is canonical state (HR-7), intake required (HR-8), physical-world bridge preferred (HR-9), epistemic honesty first-class (HR-10), Reddit privacy (HR-11).

Modes

1. design_experiment

Given an assumption from the venture-brief, produce an experiment design.

Input:

mode: "design_experiment"
assumption_id: uuid           # links to venture-brief.assumptions[]
assumption_claim: string      # the claim to test (from assumptions[].claim)
biz_type: enum               # from venture-brief intake
niche: string                # from venture-brief intake
stage: enum                  # from venture-brief intake

Flow:

1. Read venture-brief.yaml — load the assumption, existing experiments, intake context. Refuse if missing or if assumption_id not found.
2. Select method from the methods matrix (see references/experiment-design.md):
   • Interview (Mom Test) — for problem/need assumptions
   • Landing page (fake door) — for demand assumptions
   • Concierge — for solution assumptions
   • Pre-order — for willingness-to-pay assumptions
   • Ad test — for channel/audience assumptions
   • Survey — for preference/demographic assumptions (weakest method — flag this)
3. Produce experiment design:

   experiment:
     id: <uuid>
     assumption_id: <uuid>
     method: <selected>
     hypothesis: string           # "If [assumption] is true, then [observable outcome]"
     success_criteria: string     # quantitative threshold
     kill_criteria: string        # what result would falsify the assumption
     minimum_sample_size: int     # method-dependent minimum
     timeline: string             # realistic, not aspirational
     steps: list[string]          # 5-8 concrete steps the user takes
     tools_needed: list[string]   # what the user needs (Calendly, Typeform, etc.)
     cost_estimate: string        # $0 / <$50 / <$200 / custom
     risks: list[string]          # what could go wrong with this experiment
   

4. Write to venture-brief.experiments[] with status: planned
5. Return to user with the full experiment design and "here's what you do next"

Output: Structured experiment design ready for the user to execute.

2. draft_interview

Produce a Mom Test interview script for a specific assumption.

Input:

mode: "draft_interview"
assumption_id: uuid           # which assumption this interview targets
target_persona: string        # who you're interviewing ("UK accountant, 1-5 person practice")
interview_context: string     # optional — "first interview" / "follow-up after landing page"

Flow:

1. Read venture-brief. Load assumption and any prior interview evidence.
2. Apply the Mom Test protocol (see references/interview-scripts-mom-test.md):
   • Talk about their life, not your idea
   • Ask about the past, not the future
   • Less talk, more listen
   • Never pitch — extract
3. Produce a script with 10-15 questions:

   interview_script:
     target_assumption: string
     target_persona: string
     warm_up: list[string]        # 2-3 context-setting questions
     core_questions: list[
       question: string
       follow_up_prompts: list[string]
       red_flag_answers: list[string]  # answers that signal fake validation
       green_flag_answers: list[string]  # answers that signal real pain
     ]
     closing: list[string]        # 2-3 wrap-up questions including the "ask"
     interviewer_notes:
       - "If they say 'I would definitely use that' — DO NOT count this as validation (HR-V1)"
       - "If they describe a workaround they've built — this is strong behavioral evidence"
       - "If they can't describe the last time they had this problem — the pain may not be real"
   

Output: Complete interview script with red/green flag guidance.

3. capture_evidence

User reports what happened. Skill structures it into the assumption ledger.

Input:

mode: "capture_evidence"
experiment_id: uuid           # links to venture-brief.experiments[]
evidence:
  type: enum                  # interview | landing_page | ad_test | survey | concierge | other
  date: date
  assumption_id: uuid
  method: string              # "Mom Test interview" / "fake door landing page" / etc.
  raw_data:
    interviews_completed: int
    replies_received: int
    objections_heard: list[string]
    prepay_asks_made: int
    conversion_events: int
    qualitative_notes: string

Flow:

1. Read venture-brief. Load the experiment and assumption.
2. Validate the evidence artifact (HR-V5):
   • Reject if raw_data has no quantitative fields filled (interviews_completed, replies_received, conversion_events, prepay_asks_made — at least one must be > 0 or the user must explain why)
   • Reject "it went well" without numbers
   • Accept zero values if the user explicitly reports "0 conversions out of 50 visitors"
3. Determine verdict per assumption:
   • confirmed — ONLY with behavioral evidence (HR-V1): signup, prepay, workaround, switch. Verbal "I'd buy it" does NOT qualify.
   • falsified — experiment ran, results clearly below kill criteria
   • inconclusive — experiment ran, results between success and kill criteria, or sample too small to conclude
4. Assign confidence: high (large sample, clear signal) / medium (adequate sample, some noise) / low (small sample or ambiguous signal)
5. Write to venture-brief:
   • Update experiments[experiment_id].evidence with the artifact
   • Update experiments[experiment_id].verdict
   • Update experiments[experiment_id].status: completed
   • Update assumptions[assumption_id].evidence[] with reference
   • Increment interview_count if type is interview
6. Return structured summary including verdict, confidence, what it means, and what to test next

Verdict logic detail:

4. read_analytics

Browser MCP Envelope D. Reads analytics dashboards and pages for evidence capture.

Input:

mode: "read_analytics"
target: string                # URL or description: "my GA4 dashboard", "landing page at example.com"
metrics_of_interest: list[string]  # what to look for: "signups", "bounce rate", "CTR"

Flow:

1. Verify browser MCP availability. If browser MCP tools are not available, return a graceful degradation message: "Browser MCP is not available in this session. Ask the user to provide the analytics data manually."
2. Navigate to the target using ONLY Envelope D tools (see references/browser-mcp-allow-list.md):
   • navigate to load the URL
   • get_page_text to extract visible content
   • read_page for DOM structure (forms, CTAs, key elements)
   • read_network_requests for XHR/Fetch responses (GA4 JSON, GSC JSON)
   • find for natural-language element search
   • javascript_tool ONLY for read-only expressions (regex-gated — see allow-list)
   • computer ONLY for screenshot + scroll — NO clicks, NO typing
3. Extract structured metrics:

   analytics_snapshot:
     url: string
     captured_at: timestamp
     metrics:
       - name: string            # "signup_rate", "bounce_rate", "sessions"
         value: string           # "3.2%", "150", "45s"
         source: string          # "page_text", "network_xhr", "dom_element"
     observations: list[string]  # "Landing page has no clear CTA above the fold"
     raw_data_available: bool    # whether XHR captured structured data
   

4. Return for evidence capture. The analytics snapshot feeds into capture_evidence mode.

Envelope D enforcement: Any tool call not on the allow-list is BLOCKED immediately (HR-V3). The skill does not attempt the call and explains why it was blocked. See references/browser-mcp-allow-list.md for the canonical allow-list with regex patterns for javascript_tool gating.

5. evidence_review

Across all experiments, what do we know? What's still unvalidated? What should we test next?

Input:

mode: "evidence_review"
# No additional input needed — reads everything from venture-brief

Flow:

1. Read venture-brief. Load all assumptions, experiments, and evidence.
2. Build assumption status matrix:

   assumption_matrix:
     - id: uuid
       claim: string
       experiments_run: int
       latest_verdict: enum       # confirmed | falsified | inconclusive | untested
       confidence: enum
       evidence_summary: string   # 1-sentence summary of what we know
       risk_level: enum           # high (core viability) | medium (growth) | low (nice-to-have)
       next_action: string        # "run experiment X" / "sufficient evidence" / "pivot needed"
   

3. Gap analysis:
   • Which high-risk assumptions have zero evidence? (HR-V4 — surface honestly)
   • Which assumptions have only survey data? (flag as weak)
   • Which assumptions have contradictory evidence across experiments?
   • Are there enough interviews logged? (HR-V2 check for sprint readiness)
4. Sprint readiness check: can the venture advance to the Decision stage?
   • Top-3 riskiest assumptions each have >= 1 experiment with recorded evidence

   • = 1 real interview logged (HR-V2)

   • No high-risk viability assumption falsified without pivot or accepted_risk
5. Return structured review with the matrix, gaps, sprint readiness verdict, and recommended next experiments

Output:

evidence_review:
  total_assumptions: int
  tested: int
  confirmed: int
  falsified: int
  inconclusive: int
  untested: int
  interview_count: int
  sprint_ready: bool
  sprint_blockers: list[string]  # what's missing for Evidence -> Decision transition
  gap_analysis: list[string]
  recommended_next: list[string]
  risk_flags: list[string]

Evidence Capture Protocol

The skill requires user-reported artifacts to close the loop. Evidence is NOT inferred from analytics alone — the user must explicitly report what happened.

evidence_artifact:
  type: enum           # interview | landing_page | ad_test | survey | concierge | other
  date: date
  assumption_id: uuid  # links to venture-brief assumption
  method: string       # "Mom Test interview" / "fake door landing page" / etc.
  raw_data:            # user-reported
    interviews_completed: int
    replies_received: int
    objections_heard: list[string]
    prepay_asks_made: int
    conversion_events: int
    qualitative_notes: string
  verdict: enum        # confirmed | falsified | inconclusive
  confidence: enum     # high | medium | low
  verdict_rationale: string

See references/evidence-capture-protocol.md for the full protocol including verdict logic, confidence scoring, and edge cases.

Cross-Skill Integration

founder (parent)
  | intake populated, route to founder-validation
  v
founder-validation (this skill)
  | read venture-brief
  |
  |-- design_experiment --> writes to venture-brief.experiments[]
  |-- draft_interview --> returns script to user
  |-- capture_evidence --> user reports back, updates venture-brief
  |-- read_analytics --> browser MCP Envelope D, feeds capture_evidence
  |-- evidence_review --> gap analysis, sprint readiness check
  |
  v
founder-sprint (Phase 2)
  | checks evidence_review.sprint_ready before Evidence -> Decision gate

Failure Modes

Anti-Patterns

Reference Files

Read these as needed during validation work:

• references/assumption-ledger-schema.md — YAML schema for structured assumptions, linking to experiments and evidence
• references/experiment-design.md — methods matrix (interview / landing page / concierge / pre-order / ad test / survey), sample sizes, timelines, success criteria templates, cost estimates
• references/interview-scripts-mom-test.md — Mom Test protocol, question templates per assumption type, red flags, anti-patterns, "the three critical questions"
• references/browser-mcp-allow-list.md — Envelope D tool allow-list with regex patterns for javascript_tool gating, blocked tools with reasons
• references/evidence-capture-protocol.md — how to structure user-reported artifacts, verdict logic per evidence type, confidence scoring, edge cases

When NOT to Use This Skill

• User wants to generate ideas (not validate them) -- use founder-ideation
• User wants unit economics / pricing -- use founder-business-model
• User wants to build the product -- hand off to forge via sprint
• User wants legal / regulatory validation -- REFUSED (HR-1, HR-2); refer to counsel
• User wants to scrape competitor sites -- NOT in scope; Envelope D is read-only analytics for the user's own properties
• User wants to automate outreach (Envelope B/C) -- deferred to Phase 2.5; Envelope D is read-only