Anthropic's AI-native founder's playbook: four stages, exit criteria, and prompts you can copy straight out
- In May 2026, Anthropic published a 36-page founder's handbook called The Founder's Playbook, reframing the AI-native startup path into four stages — Idea, MVP, Launch, and Scale — each with explicit exit criteria.
- The core toolkit is a trio: Claude for research and strategy, Claude Code for writing code, and Claude Cowork for operations automation. The playbook includes a concrete task-to-tool mapping table.
- Each stage lists failure modes unique to the AI era — mistaking a prototype for validation, frictionless scope creep, AI-assisted confirmation bias, and agentic technical debt — paired with matching Claude exercises.
- The MVP stage's exit criterion is quantified with the Sean Ellis test: if more than 40% of active users say they'd be "very disappointed" to lose the product, that counts as a signal of product-market fit.
- The book closes with more than a dozen real startup case studies, including Carta Healthcare — which processes 22,000 surgical cases a year and cut data-extraction time by 66% — and Anything, which has helped 1.5 million users turn ideas into software.
An official playbook that redraws the founder's path into four stages
On May 6, 2026, Anthropic published a 36-page founder's handbook, The Founder's Playbook (PDF, v3), re-splitting the AI-native startup path into four stages: Idea, MVP, Launch, and Scale.
The playbook's central argument is blunt: what founders need to do hasn't changed — the same three things, find a real problem, build something that solves it, turn that into a company. What AI changes is the road to get there. It compresses that path so each stage no longer automatically demands a bigger team and a fresh funding round — the bottleneck shifts from what you're capable of building to what you choose to build.
- All three check questions answer yes
- Problem-solution fit found
- Proof on at least one of retention / payment / referral
- Sean Ellis test clears 40%
- Growth is repeatable and channel-driven
- Product holds up under production load
- Operations no longer bottleneck the founder
- One of three threshold events
- Sustainable profitability / IPO-ready / acquired
Throughout the playbook, the same three-tool kit keeps coming back: research and strategy go to Claude, coding goes to Claude Code (a coding environment where AI writes, tests, and debugs autonomously), and operations automation goes to Claude Cowork. Let's break down the four stages one by one — starting with exactly which part of the path AI compresses.
The old path looped through seven steps; the new one keeps just four
AI doesn't let founders skip any stage — what it removes is the default binding between stages. Entering a new stage used to automatically mean hiring more people, picking up a new skill set, and raising another round. That binding is now undone.
The playbook is specific about what AI replaces at each step. In research, it's an on-call domain expert for competitive analysis, market sizing, financial modeling, and drafting investment memos. In coding, it's an engineer who's always online and never blocked, compressing what used to be a whole team's workload into something a founder can deliver solo. In operations, it's an on-demand automated ops team — updating the CRM as deals move, writing the weekly report itself, and keeping product docs in sync as the product changes.
The upshot: the founder's role shifts wholesale — from the "doer" writing code, managing people, and handling daily chores, to the "orchestrator" generating ideas and directing these AI tools to execute them. The playbook flags one change here as the most consequential: it lets people with industry experience but no engineering background start companies too, widening the founder pool well beyond engineers.
Same Claude, three different workspaces
The playbook is explicit: Chat, Claude Cowork, and Claude Code all run on the same Claude — the only difference is the workspace wrapped around it. Pick the wrong one and something that should be effortless turns clunky. The table below is a selection framework you can use as-is.
| If the task is | Use this | Why |
|---|---|---|
| A single question, a quick rewrite, fast brainstorming | Chat | Fast, conversational, no setup |
| Research, analysis, or turning your files and systems into a finished document | Claude Cowork | Reads folders, connects to integrations, runs skills, can be scheduled |
| Writing code, testing, shipping software | Claude Code | Reads the codebase, has diffs, git, a dev environment |
The playbook's rule of thumb: Chat handles the endless small stuff of running a company — pulling a one-line takeaway out of a dense investment memo, fact-checking a claim before a board meeting. Claude Cowork handles the genuinely time-consuming knowledge work — turning a folder of customer call transcripts into a themed findings doc, pulling metrics from connected tools every Monday morning into a KPI brief. Claude Code is the coding environment that stands in for an engineer on the team — going from prototype to production, migrating old MVP-era code — none of it has to wait on more hires.
Task is a quick question, a rewrite, or brainstorming → use Chat (fast, conversational, no setup needed). Task is research, analysis, or turning your files and systems into a finished document → use Claude Cowork (reads folders, connects to integrations, runs skills, can be scheduled). Task is writing code, testing, or shipping software → use Claude Code (reads the codebase directly, has diffs, git, a dev environment). All three run on the same Claude — the only difference is the workspace wrapped around it.
Don't rush to code — nail down whether this is even a real problem
Every founder starts from the same place: a problem they can't stop thinking about. The Idea stage has one rule — no building until the evidence is in. The work here is research, customer interviews, competitive analysis, and an honest look at the evidence stacked against you, and all of it has to happen before Claude Code writes a single line of production code.
The playbook lays out the Idea stage as a sequence of questions to answer in order: Is this problem real, specific, and frequent enough to build a company around? Who has it, and does that add up to a market? Is anyone else already solving it, and how well? What would a solution actually need to do to fix it, and does my idea do that? Together they answer the one question that matters: is this worth building?
The key is getting specific before you move. "Everyone hates doing expense reports" is just an observation — you can't test it. Turn it into a testable hypothesis, and it actually holds up.
Everyone hates doing expense reports.
Finance managers at mid-size companies spend 4+ hours a week reconciling expense reports because their current tools don't integrate with their accounting software.
Exit criteria: all three questions must answer yes
The Idea stage's exit condition is problem-solution fit — solid qualitative evidence (mostly from real conversations) proving you're solving a real problem for real people, before you go build the solution. All three questions need to answer yes before you move on:
- Can you say who has it, how often, how badly, and what they do about it now
- The one the validation process actually revealed — not necessarily the one you assumed at the start
- You'll never get certainty at this stage — waiting for it is itself a failure mode; but the signal needs to be enough to rationally decide to build the MVP, not just run on conviction