@veyralabs/skills 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veyralabs/skills",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "VeyraSkills — A curated collection of Claude Code skills for founders, developers and AI builders",
   "bin": {
     "veyraskills": "bin/cli.js"

package/skills/venture-suite/venture-analyst/SKILL.md

@@ -9,13 +9,14 @@ Research a startup or SaaS idea and determine if it's worth building. No fluff -
 
 ## What this does
 
-Five phases, each producing structured output:
+Six phases, each producing structured output:
 
 1. **Problem Discovery** - Find evidence the problem actually exists (Reddit, HN, GitHub issues, trends)
 2. **Competitor Intelligence** - Map the landscape, find gaps, extract pricing signals
 3. **Validation Experiments** - Generate 3 prioritized experiments to test demand before building
 4. **Verdict** - Bull/Bear/Judge debate with Confidence Engine and scored recommendation
 5. **Decision Intelligence** - Contradiction detection, founder trap check, reality check, distribution plan, time-to-first-dollar
+6. **Execution & Moat** - 30-day roadmap, moat scoring, PMF simulation, market timing
 
 ## How to use
 
@@ -394,6 +395,212 @@ What would accelerate this: [specific factor]
 What would delay this: [specific risk]
 ```
 
+### Assumption Map
+
+Every startup decision rests on assumptions. Most founders know the surface ones. The dangerous ones are buried.
+
+Identify the 3 critical assumptions this startup cannot survive without. For each:
+- What the startup is betting on being true
+- Confidence level based on actual evidence collected (not gut feel)
+- What would validate or invalidate it
+
+```
+Critical Assumption A1:
+[The core belief about the problem/customer]
+Confidence: [0-100]
+Based on: [evidence or lack of it]
+Validates if: [specific observable outcome]
+Kills startup if: [falsified by X]
+
+Critical Assumption A2:
+[Usually the monetization or switching assumption]
+Confidence: [0-100]
+Based on: [evidence or lack of it]
+Validates if: [specific observable outcome]
+Kills startup if: [falsified by X]
+
+Critical Assumption A3:
+[Usually the distribution or growth assumption]
+Confidence: [0-100]
+Based on: [evidence or lack of it]
+Validates if: [specific observable outcome]
+Kills startup if: [falsified by X]
+```
+
+Rank them: most dangerous assumption first (lowest confidence that is also most critical to survival).
+
+This is not a list of things to do. It is a map of what the founder believes vs what the evidence supports.
+
+## Phase 6 - Execution & Moat
+
+**Goal:** Answer "should you dedicate the next 2 years of your life to this?" - not just "is it a good idea?"
+
+This phase converts the analysis into action and answers the defensibility question.
+
+### Execution Roadmap
+
+Use `references/execution-roadmap.md` for the full framework. Output a week-by-week plan tailored to the verdict:
+
+**If BUILD:**
+- Week 1: find 5 people with the problem (specific communities from the research)
+- Week 2: deliver value manually before building
+- Week 3: charge for it
+- Week 4: find customer 2-3 and a referral
+
+Key rule: no code until someone commits to paying. The roadmap builds toward a transaction, not a product.
+
+**If VALIDATE FIRST:**
+- Define the one critical unknown in one sentence
+- Run the cheapest test that could falsify it (2 weeks max)
+- Define pass/fail threshold before starting
+- Week 4: commit to BUILD or pivot/stop based on data
+
+**If AVOID:**
+- 2-week pivot investigation using the most interesting signal from the research
+- Or clean stop criteria with specific trigger conditions for revisiting
+
+Always include:
+```
+Do NOT build yet: [specific features to avoid and why]
+Reassess if: [specific trigger that means the plan is failing]
+```
+
+### Kill Criteria
+
+Most founders know when to start. Almost none know when to stop.
+
+Generate kill criteria calibrated to the specific idea and market type. These are not generic - they come from the evidence and experiment plan.
+
+```
+Kill Criteria for [idea]:
+
+If after [days] from starting:
+
+Experiments:
+- Fewer than [n] real customer interviews completed
+- Fewer than [n] people willing to schedule a call
+- Zero payment intent (pre-order, deposit, contract signed)
+
+Signals:
+- [specific negative signal tied to the idea]
+- [specific negative signal]
+
+-> Stop. Do not pivot yet. First answer: was the problem real or did we imagine it?
+
+Pivot trigger (instead of stop):
+If the problem gets validated but [specific conversion/monetization step] fails -> pivot to [specific narrower scope or different monetization]
+```
+
+Thresholds must be concrete numbers, not vague goals. "Not enough traction" is not a kill criterion. "Zero paying customers after 21 days of direct outreach" is.
+
+### Pivot Engine
+
+Run this when verdict = AVOID or when Kill Criteria are hit.
+
+Based on the signals collected in Phases 1-2, identify 2-3 realistic pivot directions. Pivots must be grounded in actual evidence - not invented alternatives.
+
+Pivot types to consider (from `references/lean-startup.md`):
+- **Segment pivot** - same problem, different customer (who else has this pain?)
+- **Problem pivot** - same customer, different problem (what else do they complain about?)
+- **Channel pivot** - same product, different distribution (where are buyers actually found?)
+- **Scope pivot** - same idea, 80% smaller (which one feature has the most evidence?)
+
+Output format:
+```
+Pivot Option 1: [type]
+From: [current idea]
+To: [specific pivot]
+Evidence: [signal from research that supports this direction]
+Risk: [what could still be wrong]
+
+Pivot Option 2: [type]
+From: [current idea]
+To: [specific pivot]
+Evidence: [signal from research that supports this direction]
+Risk: [what could still be wrong]
+
+Recommended pivot: [1 or 2] - because [one sentence reason]
+```
+
+Do not generate pivots if no supporting evidence exists. If the research found nothing reusable, state: "No evidence-backed pivot found. Consider a different problem space entirely."
+
+### Moat Intelligence
+
+Score all 5 moat types using `references/moat-patterns.md`. For each:
+
+```
+Distribution moat:  [1-10] - [one-line reason]
+Data moat:          [1-10] - [one-line reason]
+Community moat:     [1-10] - [one-line reason]
+Switching cost:     [1-10] - [one-line reason]
+Execution moat:     [1-10] - [one-line reason]
+
+Overall Moat Score: [weighted average of top 2]
+
+Most realistic moat: [type]
+How to build it: [specific action, not generic advice]
+```
+
+Do not score high without evidence. "We will accumulate data" is not a data moat - it is a plan. Score what exists or can realistically exist in 6 months.
+
+### PMF Simulation
+
+Generate 3 ICP personas based on the evidence found in Phases 1-2. Each persona is grounded in actual signals from the research, not invented.
+
+```
+Persona A: [job title / situation]
+- Current workflow for the problem: [specific, from research]
+- What they hate about current solution: [from Reddit/HN quotes]
+- What they pay today: [from competitor pricing research]
+- What they would never pay for: [inferred from pain signals]
+- Adoption trigger: [what would make them switch]
+- Adoption blocker: [what would stop them even if interested]
+```
+
+Then simulate a 4-week adoption arc for each persona:
+
+```
+Week 1: discovers product (channel: [specific channel from distribution plan])
+Week 2: [tries free / books demo / reads docs]
+Week 3: [converts / churns / stalls - and why]
+Week 4: [retained / referred / cancelled]
+```
+
+From the 3 simulations, identify the PMF friction points:
+```
+Main adoption blockers:
+- [blocker 1]: affects [n/3] personas
+- [blocker 2]: affects [n/3] personas
+
+Easiest persona to convert: [A/B/C] - because [reason]
+Start here.
+```
+
+### Market Timing
+
+Based on data already collected (trend, GitHub, competition):
+
+```
+Market timing: [Too Early / Good Window / Late / Saturated]
+
+Signals:
++ [positive timing signal]
++ [positive timing signal]
+- [negative timing signal]
+
+Window estimate: [closes in X months / open for X years / unclear]
+
+Timing verdict:
+[One sentence. Is this the right moment? Why?]
+```
+
+Timing patterns to detect:
+
+- **Too early:** trend rising but community not formed, infrastructure missing, no paying competitors yet
+- **Good window:** trend rising, 2-5 established players with clear weaknesses, market education done by competitors
+- **Late entry:** dominant player has >50% share and a free tier, market consolidating
+- **Saturated:** 10+ funded competitors, VC money flooding in, CAC rising, differentiation collapsing
+
 ## Enhancement detection
 
 Run at session start to unlock better sources:
@@ -436,6 +643,8 @@ From `calculate_evidence_score()` in `sources.py`:
 - `references/blue-ocean.md` - Value Curve, ERRC Grid, finding uncontested space
 - `references/traction.md` - 19 acquisition channels, Bullseye framework
 - `references/founder-traps.md` - 8 trap patterns with evidence criteria
+- `references/moat-patterns.md` - 5 moat types with scoring criteria 1-10
+- `references/execution-roadmap.md` - 30-day BUILD/VALIDATE/AVOID roadmap framework
 
 ## Output principles
 
@@ -447,3 +656,6 @@ From `calculate_evidence_score()` in `sources.py`:
 6. Check for founder traps before finalizing verdict
 7. Verdict must commit - no "it depends" without specifics and a path forward
 8. Distinguish Opportunity Score from Startup Score
+9. Phase 6 is not optional - the roadmap is what makes the analysis useful
+10. Moat scoring must be honest - score what exists, not what is planned
+11. Tag every factual claim: `[EVIDENCE]` (backed by collected data), `[INFERENCE]` (logical conclusion from data), or `[SPECULATION]` (no direct data, informed guess). Never mix them silently. This applies to the Bull case, Bear case, moat scoring, PMF simulation, and market timing sections.

package/skills/venture-suite/venture-analyst/references/execution-roadmap.md

@@ -0,0 +1,187 @@
+# Execution Roadmap Framework
+
+The analysis means nothing if the founder doesn't know what to do on Monday morning.
+
+This framework converts a venture-analyst verdict into a concrete 30-day action plan. The output is not generic advice - it is specific actions based on the evidence collected in Phases 1-5.
+
+---
+
+## The core principle
+
+Most validators end with BUILD or AVOID. That is not enough.
+
+The right output is:
+- What to do this week (not "validate the idea" - specific tasks)
+- What NOT to build yet (and why)
+- When to stop and reassess (specific trigger conditions)
+
+The roadmap changes based on the verdict:
+- **BUILD** → 30-day sprint to first paying customer
+- **VALIDATE FIRST** → 30-day experiment plan
+- **AVOID** → pivot path or stop criteria
+
+---
+
+## BUILD path - 30-day roadmap
+
+The goal is one paying customer in 30 days. Not an MVP. Not a waitlist. One customer who pays.
+
+### Week 1 - Find the customer before building
+
+Actions:
+1. Identify 50 people who have the problem (from the research: which subreddits, which GitHub repos, which communities had the most signal?)
+2. Reach out to 20 with a Mom Test message - not a pitch, a question about their current workflow
+3. Book 5 discovery calls
+4. Run all 5 calls using Mom Test structure from `references/mom-test.md`
+5. By end of week: can you describe the customer's pain in their exact words?
+
+Do NOT build anything this week.
+
+Decision gate: if you cannot find 5 people willing to talk, the ICP is wrong. Stop and reassess before continuing.
+
+### Week 2 - Build only what closes the first sale
+
+Based on the 5 conversations:
+1. Identify the one outcome the customer cares most about
+2. Can you deliver that outcome manually? (Concierge MVP)
+3. If yes: offer to do it for free or at a steep discount for 2-3 people
+4. If the outcome requires software: build only the path from input to that outcome. Nothing else.
+
+Scope rule: if it takes more than 5 days to build, you are building too much.
+
+Decision gate: if you cannot articulate what the customer is paying for in one sentence, do not build yet.
+
+### Week 3 - Deliver and charge
+
+1. Deliver the concierge MVP or minimal software to the 2-3 people from Week 2
+2. At delivery: ask "would you pay [price] per month for this if it continued?"
+3. If yes: send them a payment link (Stripe, Gumroad, bank transfer - whatever works)
+4. If no: ask what would have to be different for them to pay
+
+First payment is the signal. Not a letter of intent. Not "I would pay". An actual transaction.
+
+Decision gate: if nobody pays after Week 3, you have a problem with price, value, or ICP. Identify which one before continuing.
+
+### Week 4 - Stabilize and find customer 2-3
+
+1. Deliver reliably to paying customer 1
+2. Ask for referral: "who else do you know with this problem?"
+3. Run outreach to 10 more people from the original 50 list
+4. Goal: 2-3 paying customers by end of month
+
+---
+
+## VALIDATE FIRST path - 30-day experiment plan
+
+The goal is to answer the one critical unknown identified in Phase 5.
+
+### Week 1 - Define the question precisely
+
+Write this sentence: "We do not know if [specific assumption]. If we knew [assumption] is true, we would build. If false, we would not build."
+
+Examples:
+- "We do not know if freelancers will pay for automated invoicing when free tools exist."
+- "We do not know if HR teams have budget for this outside their annual planning cycle."
+
+Everything in the next 3 weeks answers this one question.
+
+### Week 2 - Run the cheapest test that could falsify it
+
+Based on the assumption type:
+
+| Assumption type | Best test | Cost | Time |
+|----------------|-----------|------|------|
+| Does the problem exist? | 10 Mom Test interviews | 0 | 1 week |
+| Will they pay? | Concierge MVP with payment ask | 0 | 2 weeks |
+| Does the message resonate? | Fake door landing page | 0-30€ | 1 week |
+| Is the ICP right? | Cold outreach to 3 different segments | 0 | 1 week |
+
+Do not run more than one test at a time. You need clean signal.
+
+### Week 3 - Collect and evaluate data
+
+By end of week 3 you need a number against a threshold:
+- Interviews: at least 7 out of 10 describe the same problem unprompted
+- Payment ask: at least 2 out of 5 say yes and follow through
+- Fake door: CTR above 5% from cold traffic
+- ICP test: one segment responds 3x better than others
+
+### Week 4 - Decision
+
+Three possible outcomes:
+
+**Assumption confirmed:** move to BUILD path. Start Week 1 of the BUILD roadmap.
+
+**Assumption partially confirmed:** the test worked but raised a new question. Run a second 2-week experiment targeting the new unknown.
+
+**Assumption falsified:** the critical assumption is wrong. Before stopping:
+- Is there a pivot? (different customer, different problem, different solution)
+- If yes: restart from Phase 1 with the new hypothesis
+- If no: stop. Time is the most valuable resource.
+
+---
+
+## AVOID path - what to do instead
+
+If the verdict is AVOID, the roadmap is not "do nothing." It is:
+
+### Option A - Pivot investigation (2 weeks)
+
+The research surfaced something. What was the most interesting unexpected signal?
+- A different customer segment with stronger pain
+- A related problem that nobody is solving
+- A gap in the competitor landscape that the original idea missed
+
+Spend 2 weeks doing Phase 1 research on the pivot hypothesis before committing.
+
+### Option B - Clean stop criteria
+
+If no pivot is visible, document:
+- What was learned (specific, honest)
+- What would have to change in the market for this to be worth revisiting
+- Time horizon: reassess in [6/12/24] months if [specific trigger] occurs
+
+This is not failure. It is validated learning. The next idea starts from a better place.
+
+---
+
+## Roadmap anti-patterns
+
+**Anti-pattern 1: Building before selling**
+The roadmap assumes zero code until someone has committed to paying. Build only what closes the next sale.
+
+**Anti-pattern 2: Optimizing before validating**
+Do not improve the landing page conversion rate before you have 100 cold visitors. Do not A/B test before you have a working baseline.
+
+**Anti-pattern 3: Scaling before repeating**
+Do not invest in marketing before you have 3 customers who came through the same process. One customer is an anecdote. Three is a pattern.
+
+**Anti-pattern 4: Measuring vanity metrics**
+The only metric that matters in week 1-4 is: did someone pay? Every other metric is a proxy.
+
+**Anti-pattern 5: Moving the goalposts**
+Define success criteria before starting each week. Do not redefine "success" after seeing results.
+
+---
+
+## Output format for roadmap
+
+```
+## 30-Day Execution Roadmap
+
+Path: [BUILD / VALIDATE FIRST / AVOID]
+
+Critical constraint: [the one thing that must be true for this plan to work]
+
+Week 1: [specific tasks + decision gate]
+Week 2: [specific tasks + decision gate]
+Week 3: [specific tasks + decision gate]
+Week 4: [goal + decision]
+
+Do NOT build yet:
+- [specific feature or system to avoid]
+- [reason]
+
+Reassess if:
+- [specific trigger that means the plan is failing]
+```

package/skills/venture-suite/venture-analyst/references/moat-patterns.md

@@ -0,0 +1,176 @@
+# Moat Patterns
+
+A moat is why you keep customers after a competitor copies your features. Without a moat, you build a product, not a business.
+
+Most startup validators say "competitive advantage" and leave it there. This reference gives scoring criteria for 5 real moat types so the analysis can score each one and identify which is most realistic for a given idea.
+
+---
+
+## The 5 moat types
+
+### 1. Distribution Moat
+
+You control a channel others cannot easily access.
+
+**What it looks like:**
+- Exclusive partnership with a platform (e.g. pre-installed on hardware)
+- Large owned audience (email list, YouTube, community)
+- SEO dominance in a niche that takes years to replicate
+- Embedded in a workflow that creates daily habit (Slack, Notion)
+
+**Evidence signals (score higher for each present):**
+- Founder already has relevant audience or network
+- Product embeds into existing workflow daily
+- Partnership or distribution deal possible that others can't easily get
+- SEO moat: high-intent keywords with low competition
+
+**Score 1-10:**
+- 1-3: No distribution advantage, same channels as competitors
+- 4-6: Some channel advantage but replicable with money
+- 7-10: Structural distribution advantage that compounds over time
+
+**Most realistic for:** content businesses, platforms with network effects, tools that embed into a daily workflow
+
+---
+
+### 2. Data Moat
+
+You accumulate proprietary data that makes your product better over time and is impossible to replicate from scratch.
+
+**What it looks like:**
+- Each user interaction improves the model/output for all users
+- Unique dataset nobody else has (e.g. proprietary industry data)
+- Network of data contributors locked in by switching cost
+- Longitudinal data that takes years to accumulate
+
+**Evidence signals:**
+- Product gets meaningfully better with more users or usage
+- Data collected is not available from public sources
+- Users contribute data as part of normal use (not just consume)
+- The gap between early data and mature data is the moat
+
+**Score 1-10:**
+- 1-3: Uses same public data sources as everyone else
+- 4-6: Collects user data but competitors could replicate with time
+- 7-10: Proprietary data flywheel that widens with scale
+
+**Most realistic for:** AI products, marketplaces, analytics platforms, any product where N+1 users make the product better for all N users
+
+---
+
+### 3. Community Moat
+
+Users identify with the product and each other. Leaving means leaving the community.
+
+**What it looks like:**
+- Strong brand identity (users say "I'm a [product] user" as part of identity)
+- Active user community that is product-adjacent (Slack, Discord, events)
+- User-generated content that attracts more users
+- Power users who become advocates and contributors
+
+**Evidence signals:**
+- Reddit or HN discussions about the product are enthusiastic, not just transactional
+- Users refer others without being asked
+- Community exists or could exist around the problem space
+- Identity signal: does the target customer identify strongly with a community?
+
+**Score 1-10:**
+- 1-3: No community signal, purely transactional product
+- 4-6: Some user loyalty but no real community
+- 7-10: Product is central to a user identity or community
+
+**Most realistic for:** developer tools, creator tools, niche B2B, products solving problems with strong in-group identity
+
+---
+
+### 4. Switching Cost Moat
+
+Leaving is painful because of data, integrations, learned behavior, or sunk cost.
+
+**What it looks like:**
+- Data locked in proprietary format
+- Deep integration into other tools (replacing means replacing the whole stack)
+- Trained behavior - users have built muscle memory around the product
+- Team adoption - everyone on the team uses it, coordination cost to switch
+
+**Evidence signals:**
+- Product stores user data that is hard to export
+- Integration depth: does it connect to 5+ other tools in the workflow?
+- Time-to-value is long (users invest time before they get value)
+- Team product vs individual product (team switching cost >> individual switching cost)
+
+**Score 1-10:**
+- 1-3: Easy to replace, data fully portable, no integrations
+- 4-6: Some friction to switch but not prohibitive
+- 7-10: Switching requires significant time, data migration, or retraining
+
+**Most realistic for:** B2B SaaS, CRMs, project management, any product that stores meaningful user data or integrates deeply
+
+---
+
+### 5. Execution Moat
+
+The team can build and ship faster or better than others. Not a durable moat alone, but can be decisive in a fast-moving market.
+
+**What it looks like:**
+- Unique domain expertise that takes years to acquire
+- Technical complexity that requires rare skills
+- Speed advantage from existing infrastructure or team
+- Regulatory or compliance knowledge that creates a barrier
+
+**Evidence signals:**
+- Founder has 5+ years of domain expertise
+- Technical stack requires rare specialization
+- Regulatory approval process exists (creates time barrier for followers)
+- Existing codebase or infrastructure gives head start
+
+**Score 1-10:**
+- 1-3: Anyone with enough money can hire the team to replicate this
+- 4-6: Some execution advantage but not structural
+- 7-10: Rare expertise or regulatory barrier that cannot be bought quickly
+
+**Most realistic for:** deep tech, regulated industries, products where domain expertise is genuinely scarce
+
+---
+
+## Moat Scoring Guide
+
+Score each moat 1-10 using the criteria above. Then:
+
+**Moat Score = weighted average:**
+- Take the top 2 moat scores
+- The highest becomes the primary moat
+- The second becomes the secondary moat
+- Overall Moat Score = (primary * 0.6) + (secondary * 0.4)
+
+**Interpretation:**
+| Score | Meaning |
+|-------|---------|
+| 1-3 | No real moat. Features will be copied. Compete on speed only. |
+| 4-5 | Weak moat. Some defensibility but competitors can close the gap. |
+| 6-7 | Moderate moat. Viable business, but needs to strengthen before scaling. |
+| 8-10 | Strong moat. Structural advantage that compounds with growth. |
+
+**Critical output:**
+After scoring, answer: "What is the most realistic moat for this idea, and what specific actions build it?"
+
+Do not just name the moat. Give the action. Example:
+- Data moat: "Every analysis run should store anonymized patterns. At 1,000 analyses, the pattern database becomes a proprietary asset."
+- Community moat: "Build in public. Ship a free tool that attracts the exact ICP and turns them into advocates before monetizing."
+- Distribution moat: "Identify the one community where the ICP concentrates and become the go-to contributor before launching."
+
+---
+
+## Common moat mistakes
+
+**Mistake 1: Confusing features with moats**
+"We have AI" is not a moat. Every competitor will have AI. The question is what the AI produces that is unique and hard to replicate.
+
+**Mistake 2: Assuming complexity = moat**
+Hard to build does not mean hard to copy. Once you show it works, a well-funded competitor can hire the engineers.
+
+**Mistake 3: Planning a moat that requires scale you don't have yet**
+Data moats require data. Network effects require network. These are goals, not current advantages. Score them based on realistic trajectory, not end state.
+
+**Mistake 4: Relying on execution moat alone**
+Speed is not a business. It buys time to build a real moat. Always pair execution moat with a second structural moat.

package/skills/venture-suite/venture-analyst/templates/verdict.md

@@ -199,6 +199,117 @@ Alternative path: [reduced scope or different entry point]
 **What would accelerate this:** [factor]
 **What would delay this:** [risk]
 
+### Assumption Map
+
+```
+A1 (most dangerous): [core belief about problem/customer]
+Confidence: [0-100]
+Based on: [evidence or lack of it]
+Validates if: [observable outcome]
+Kills startup if: [falsified by X]
+
+A2: [monetization or switching assumption]
+Confidence: [0-100]
+Based on: [evidence or lack of it]
+Validates if: [observable outcome]
+Kills startup if: [falsified by X]
+
+A3: [distribution or growth assumption]
+Confidence: [0-100]
+Based on: [evidence or lack of it]
+Validates if: [observable outcome]
+Kills startup if: [falsified by X]
+```
+
+**Know:** [what the evidence clearly supports]
+**Believe:** [what is inferred but not proven]
+**Imagining:** [what has no data behind it]
+
+---
+
+## Phase 6 - Execution & Moat
+
+### Moat Intelligence
+
+| Moat type | Score (1-10) | Reason |
+|-----------|-------------|--------|
+| Distribution | [n] | [one line] |
+| Data | [n] | [one line] |
+| Community | [n] | [one line] |
+| Switching cost | [n] | [one line] |
+| Execution | [n] | [one line] |
+
+**Overall Moat Score:** [weighted avg of top 2]
+**Most realistic moat:** [type]
+**How to build it:** [specific action, not generic advice]
+
+### PMF Simulation
+
+**Persona A:** [job title / situation]
+- Current workflow: [specific]
+- Main pain: [from research quotes]
+- Adoption trigger: [what makes them switch]
+- Adoption blocker: [what stops them]
+- Simulated arc: discovers (Week 1) -> [Week 2] -> [Week 3: converts/churns] -> [Week 4]
+
+**Persona B:** [job title / situation]
+- [same structure]
+
+**Persona C:** [job title / situation]
+- [same structure]
+
+**PMF friction report:**
+- Main blockers: [list, note how many personas affected]
+- Easiest persona to convert first: [A/B/C] - because [reason]
+
+### Market Timing
+
+```
+Timing: [Too Early / Good Window / Late / Saturated]
+
+Signals:
++ [positive]
+- [negative]
+
+Window: [closes in X months / open for X years / unclear]
+Verdict: [one sentence]
+```
+
+### Execution Roadmap
+
+**Path:** [BUILD / VALIDATE FIRST / AVOID]
+**Critical constraint:** [the one thing that must be true]
+
+| Week | Actions | Decision gate |
+|------|---------|--------------|
+| 1 | [specific tasks] | [pass/fail condition] |
+| 2 | [specific tasks] | [pass/fail condition] |
+| 3 | [specific tasks] | [pass/fail condition] |
+| 4 | [goal] | [commit or reassess] |
+
+**Do NOT build yet:**
+- [feature/system] - [reason]
+
+**Reassess if:** [specific trigger condition]
+
+### Kill Criteria
+
+```
+If after [n] days from starting:
+
+< [n] real customer interviews completed
+< [n] people willing to schedule a call
+  Zero payment intent (pre-order, deposit, or signed LOI)
+  [idea-specific negative signal]
+
+-> Stop. Do not pivot yet.
+   First answer: was the problem real or did we imagine it?
+
+Pivot trigger (instead of stop):
+If problem is validated but [specific step] fails
+-> [specific narrower pivot]
+```
+
 ---
 
 ## Next Steps
@@ -238,3 +349,24 @@ If not: [specific pivot or kill condition].
 
 **Adjacent opportunity (if found):**
 [Related problem the research surfaced that IS worth pursuing.]
+
+### Pivot Engine
+
+[If no evidence-backed pivot exists: "No evidence-backed pivot found. Consider a different problem space entirely."]
+
+[If pivots found:]
+```
+Pivot Option 1: [segment / problem / channel / scope]
+From: [current idea]
+To: [specific pivot]
+Evidence: [signal from research that supports this]
+Risk: [what could still be wrong]
+
+Pivot Option 2: [segment / problem / channel / scope]
+From: [current idea]
+To: [specific pivot]
+Evidence: [signal from research that supports this]
+Risk: [what could still be wrong]
+
+Recommended: Option [1/2] - [one sentence reason]
+```