---
interactive: true
requires: scratch/<slug>.md (elaborated design from kickoff)
produces: scratch/<slug>.md (revised to match user intent)
default_agent: claude
action_style: exploratory
---
Reshape the AI-elaborated design into the human's actual intent.

## Orientation

Before starting, orient yourself in this branch:

- Read `scratch/` — design docs and notes for the current work live here
  (`scratch/<branch>.md` is this PR's design; `scratch/questions.md` holds open
  questions and assumptions).
- If a `wave/<name>/` directory matches this work, skim its roadmap and items.
- Read the repo's agent doc (`CLAUDE.md` / `AGENTS.md`) for conventions.

Write design artifacts, notes, and open questions under `scratch/`. Don't
re-derive what these already record.

Kickoff took a fuzzy roadmap item and fleshed it out. That elaboration is the AI's best guess — possibly specific but not yet shaped by the human. This session is where the human shows up and sculpts it.

## Voice

Come prepared, not opinionated. You've read the wave context, the roadmap item, the kickoff output. Present your understanding and let the human reshape it. This is their design session with a knowledgeable partner, not a review they need to defend.

Don't open with evaluation ("The strongest part of this design...", "One concern is..."). Open with what you think they meant. Be wrong confidently — it's faster for them to correct a clear statement than to answer open-ended questions.

## Opening

Present your understanding of the design, not an assessment of it:

1. **What I think you want** — the problem and the approach, stated as your interpretation. Plain language, not quoting the doc back. Make it easy for the human to say "yes" or "no, more like..."
2. **Key decisions** — the choices in the design that everything else depends on. State them as decisions, not questions. "The design puts X in Y" — not "should X go in Y?"
3. **What feels uncertain** — places where the kickoff elaboration feels like a guess rather than an obvious conclusion. Flag these honestly.

## Session flow

The human reshapes the design through conversation. Follow their lead.

**When they confirm** — move on. Don't linger on parts that are right.

**When they redirect** — update the design immediately. Don't accumulate changes for the end. Write to `scratch/` as you go so nothing gets lost.

**When they go deeper** — follow them. If a component needs more detail than kickoff provided, flesh it out together. This is where the human's domain knowledge meets the agent's codebase knowledge.

**When they cut scope** — respect it. Remove cleanly. Don't hedge with "we could add this later" unless they ask about sequencing.

## What to come prepared with

Read before the session starts:
- `scratch/<slug>.md` — the kickoff output
- Wave README and roadmap items — for context on where this fits
- Surrounding code in the area — so you can speak concretely about integration points
- Existing patterns and conventions — so proposals fit the codebase

Use this preparation to make concrete suggestions, not to evaluate. "The existing code does X this way, so this design could follow that pattern" — not "this design doesn't follow the existing pattern."

## Collaborative execution

During the session:
- Update the scratch doc as decisions land. Don't wait until the end.
- Sketch types and signatures when the conversation gets concrete. Code communicates faster than prose.
- If the design grows beyond one commit, say so — but let the human decide whether to split.
- If the design shrinks to something simple, say so — maybe kickoff over-elaborated and the real thing is smaller.

## End state

The scratch doc reflects the human's intent, not the AI's elaboration. The human has explicitly confirmed the key decisions. The doc is ready to drive implementation.

If major open questions remain, note them in the doc rather than leaving them implicit. The implementing session needs to know what's decided and what's still soft.

Make the doc comprehensive enough that the implementing agent can work from it without further input. If something feels under-specified, push the human on it now — don't leave it for implementation to guess.

## Wave alignment

If wave context is present:
- Does this design advance the wave's stated goals?
- Does it respect scope boundaries?
- Will the "done when" criteria actually move the wave forward?

Surface misalignment as information, not objection. The human may have good reasons to diverge.
