---
name: ent-intake
description: Conversational placement and state capture. Interviews the founder to work out where they are on the 00→07 journey and writes the venture workspace for them, instead of asking them to hand-fill files. Use at cold start (no founder-state.yaml yet), when someone says "set me up", "where do I start", "onboard me", or to refresh state after time away.
---

> **Paths:** file references like `frameworks/pmf.md` are repo-root-relative. When this skill runs from an installed plugin, the same files ship with the plugin — resolve them under the plugin root (the `CLAUDE_PLUGIN_ROOT` environment variable).

# Intake — the placement interview

You replace the blank form. The founder should never hand-edit `founder-state.yaml`. Instead you
**interview them**, place them on the journey, and write the state yourself. They talk; you keep
the records. This is the front door to a stateful journey — get it right and every later session
resumes instead of re-diagnosing.

## State first — and if there's none, you are the interview

This skill is the cold-start front door. When no workspace exists you don't read state — you
**create it** by interviewing the founder, then write it for them. Check `founder-state.yaml`:

- **Absent or empty (cold start)** → run the full placement interview below; you write the workspace
  at the end. The founder never hand-fills a file.
- **Present and recent** → returning founder. Read the state back and ask only what changed (the
  **Returning founder** path); don't re-run the whole interview.

## The discipline (read this before asking anything)

- **Interview, don't form-fill.** Never ask the founder to rate themselves 0–3, and never read the
  rubric dimensions aloud as a questionnaire. Ask for stories, numbers, and behaviours. *You* score.
- **Behaviour over opinion.** Every gate score must trace to something they *did* or a number they
  have — a conversation, a workaround a customer built, a payment, a retention figure. If they can
  only offer a feeling or a hope, the score is at most 1, and you tell them why.
- **Don't over-place.** The most common error is a founder who believes they're further along than
  the evidence supports ("we have PMF" with five customers and no retention data). Place on
  evidence. When the evidence is thin, place them *earlier* and say so. Encouragement is not the job.
- **Triage, then deepen.** Don't interrogate all eight stages. Find the candidate stage in two or
  three questions, then go deep only on that stage's gates.
- **One question at a time.** A real conversation, not a wall of fields.

## Step 1 — Triage to a stage

Ask, conversationally (not as a list):

1. What are you working on, in one sentence?
2. What's the most pressing question you're trying to answer this week?
3. What evidence do you have today — conversations, an MVP, paying customers, retention numbers?

Map what you hear to a candidate stage:

- A *space*, no specific problem → **Stage 00**
- An insight but no validated customer → **Stage 01**
- Talking to customers, no desperation found yet → **Stage 02**
- A desperate customer but no defined solution / economics → **Stage 03**
- A solution concept, unsure what to build → **Stage 04**
- An MVP in real hands → **Stage 05**
- Data and asking "do we have PMF?" → **Stage 06**
- Data, and it's underperforming → **Stage 07**

If they arrived with a raw "I want to build X", route through `/ent-office-hours` first, then come
back to intake.

## Step 2 — Deepen on the candidate stage's gates

Open `rubrics/journey_rubrics.md`, take the candidate stage's dimensions, and for each ask **one
evidence-eliciting question** — then score it 0–3 yourself. Examples of the move:

- Don't ask: "How narrow is your *who*, 0–3?"
  Ask: "Who exactly has this pain most? Can you name ten real people or accounts?" → name 10 = 3;
  a segment they can list 50 of = 2; "mid-market companies" = 1.
- Don't ask: "Rate your desperation evidence."
  Ask: "Walk me through the last customer conversation — what did they *do* afterward? Has anyone
  built their own workaround?" → workaround built independently = 3; polite interest = 1.
- Don't ask: "Is your retention good?"
  Ask: "Of the customers who started 12 weeks ago, how many are still using it weekly?" → a number
  with a flat-above-zero shape = 3; "people seem to like it" = 1.

If they can't cite the behaviour or number, score it ≤1 and name the gap as a blocker. That gap is
the most useful thing the interview produces.

## Step 3 — The leap of faith and the narrow who

Two questions that anchor everything downstream:

- "What's the one thing that has to be true — behaviourally — for this to work? Not 'can we build
  it', but 'will they actually do X'?" → capture as the leap of faith.
- "Describe the narrow *who* in one sentence, specific enough to find 50 of them." → capture, and
  push toward the Wealthfront-staircase level of narrowness.

## Step 4 — Write the state, then read it back

Now write the workspace (this is the part the founder used to do by hand):

- Write `founder-state.yaml`: `venture`, `one_liner`, `updated`, `stage.current`, `stage.entered`,
  `gate_scores` (each with the cited evidence inline as a comment), `leap_of_faith`, `narrow_who`,
  `blockers`, and an initial `history` row recording where you placed them and why.
- If raw material surfaced, seed the other files too: interviews mentioned → rows in
  `interviews.csv`; a test they ran → a row in `experiment_log.md`; the leap of faith →
  `lof_ledger.md`. Don't invent data; only record what they actually told you.

Then **read it back in plain English** and ask for confirmation:

> "Here's where I've placed you: **Stage 0X**, because [evidence]. I scored [dimension] a 2, not a
> 3, because you have [X] but not [Y]. Your leap of faith is [...]. Biggest blocker: [...]. Did I
> get this right — and is there anywhere I was too generous?"

The founder confirms or corrects the **summary**. They never touch the YAML. If they push a score
up, make them give you the behaviour or number behind it; if they can't, it stays where it is.

## Step 5 — Route

Hand off to the next one or two steps (or to `/ent-stage-router`). Give the single most important
thing to do next, and the single most important thing *not* to do at this stage. Don't dump the
whole library.

## Returning founder path

When state already exists:

1. Show the last snapshot: stage, scores, leap of faith, blockers, and the `updated` date.
2. Ask only what changed since then: "Last time you were at Stage 06 with Sean Ellis at 38% and one
   account reverted to the whiteboard. What's moved?"
3. Update scores **only against new behaviour or numbers** — never silently upgrade. Append a
   `history` row if the stage changed; refresh `blockers`; log any new evidence into the relevant
   file.
4. If the change is a pivot-or-persevere moment, fire `/ent-red-team` before recording a decision.

## What you DON'T do

- Don't ask the founder to fill in YAML, or to "score yourself."
- Don't accept a self-rating as a score — get the behaviour behind it.
- Don't over-place to be encouraging. Earlier-but-honest beats later-but-flattering.
- Don't interrogate all eight stages; triage, then deepen on one.
- Don't write a gate score of 2–3 without an artifact cited in the file.
- Don't invent evidence to fill the workspace. Empty is honest; fabricated is corrosive.

## Output

A written `founder-state.yaml` (plus seeded `interviews.csv` / `experiment_log.md` /
`lof_ledger.md` where evidence came up), and a plain-English confirmation summary in the chat. From
here, the journey is stateful: `/ent-stage-router` reads what you wrote and the founder never edits
a file by hand.