Practice
Before You Build
An agent builds whatever it is told, fast. So the careful builders spend most of their time on what to tell it. Here is how much time they give the plan, what they hand the agent on day one, and the tools that help.
Most of the time goes to the plan
FactualBuilders who measured it put 80 to 85 percent of their time into planning.
The number goes around as “about 80 percent”. These are the people who wrote down their own figure.
Jeffrey Emanuel (Agent Flywheel)
of his time and energy in the planning phases
Jarod Taylor (Jarod Taylor; Jarod Taylor)
planning with Opus, then Sonnet subagents swarm
cgvas, on Hacker News (cgvas)
5 days planning, about 8 hours coding
Harper Reed is the counterweight: his whole spec-and-plan loop takes maybe 15 minutes (Harper Reed). The share matters less than doing it before the agent writes code.
The day-one pack
FactualSix things builders hand the agent before it writes a line.
Each part comes from someone who uses it. The order is ours.
The idea, argued out
Have the model ask you one question at a time until there is a spec you could hand to a developer. (Harper Reed)
The spec
One spec.md: requirements, architecture decisions, data models and a testing strategy. (Addy Osmani)
The boundaries
Structure, style, how it is tested, and what the agent must not touch. Just enough, not everything. (Addy Osmani)
Who it is for
User stories with acceptance criteria. Kiro writes these into requirements.md. (Kiro)
The look
A frame built from real components and tokens, so the code matches the design system instead of guessing from a screenshot. (Figma; Anthropic)
References
Screenshots of screens you admire. v0 reads layout, colors and components from one; a Figma file does better. (Vercel; Whimsical)
A brief to start from
# <Project name> ## Why Who it is for, what hurts today, and what a win looks like. ## What User stories, each with how you will know it works. ## How Stack, architecture, data, and how it is tested. ## Boundaries What the agent must not touch. What needs your approval. ## Look Design system or tokens. Screenshots you admire, and why. ## Not now Ideas that wait for the next version.
Ours, put together from the pack above. Keep it in the repo, say docs/vision.md, and point the agent's instruction file at it. How agent files work.
Plan mode
FactualThe agent reads and proposes, and changes nothing until you approve.
The coding agents ship a mode for this. In Claude Code’s plan mode the agent researches and proposes changes without making them; edits stay blocked until you approve the plan (Anthropic). Cursor’s Plan Mode asks clarifying questions and writes a plan you can edit before it builds (Cursor).
Addy Osmani starts there: describe the build in plan mode and let the agent draft the spec while it explores the existing code (Addy Osmani). Hannah Stulberg uses it to agree on the approach before Claude changes anything (Hannah Stulberg).
Spec-driven development
FactualWrite the spec first, then hand it to the agent. Four tools that structure it.
Birgitta Böckeler defines it as writing a spec before writing code with AI: documentation first (Birgitta Böckeler). Laura Tacho puts it the same way: the spec is made during planning, then handed to an agent (Laura Tacho).
| Tool | Maker | What you write first |
|---|---|---|
| Spec Kit | GitHub | Specify what and why, then Plan the stack and constraints (Den Delimarsky) |
| Kiro | Kiro | requirements.md, then a design and tasks (Kiro; Birgitta Böckeler) |
| BMad | Brian Madison | Brief, PRD, UX, build, review (Brian Madison) |
| Taskmaster | Eyal Toledano | A detailed PRD at .taskmaster/docs/prd.txt (Eyal Toledano) |
Of the three she tried, Böckeler found Kiro the simplest (Birgitta Böckeler). And the steps are not a ritual: GitHub’s launch post lays Spec Kit out as phases, while its README now calls them independent entry points, not mandatory phases (Den Delimarsky; GitHub).
Draw it first
FactualSketches, wireframes and boards that turn into something an agent can build from.
Stitch
A whiteboard sketch, screenshot or rough wireframe in; UI and front-end code out in minutes. (Google)
Claude Design
Product managers sketch feature flows and hand them to Claude Code. It applies the team’s design system. (Anthropic)
FigJam
A generate-project-plan skill turns docs, code and conversations into a board for an engineering critique. (Caroline Okun)
Figma
Design the frame Claude Code will read, with the real components and tokens. (Figma)
Whimsical
Name an app and it pulls key screens from Mobbin into editable wireframes, or bring screenshots. (Whimsical)
Notion
Draft in Claude Code, push to Notion for the team, and pull meeting notes back in. Setup took under 30 minutes. (Hannah Stulberg)
The prices for these tools are on the Studio.
Storyboards: how filmmakers and game makers plan
FactualFilm and game makers plan the same way, with a script, a shot list and a handbook.
Zack London
A film does not come out of one prompt. He starts from a script and a shot list, then makes hundreds or thousands of images and clips (The Hollywood Reporter).
PJ Ace
He cut a 20-minute passage to a 3-minute script, then had an agent make 30 looks for each character before any video (PJ Ace).
Antti Kananen
His handbook picks the platform, then the smallest design docs, then proves the risky part. Agents, he says, are good at expanding the wrong spec (Antti Kananen).