Write Spec Agent Skill

Write Spec

Turn a large feature into a ladder of small contracts. Each rung should be

understandable to the human, testable by an agent, and useful before the

whole feature is done.

First Principles

• Grill before planning. Ask one question at a time until you know the

desired outcome, non-goals, review surface, sacred contracts, missing

assets, and first useful playable checkpoint. Give your recommended

answer with each question so the user can accept, reject, or edit it.

Inspect the repo instead of asking questions the code can answer.

Close the interview by asking whether the plan must carry backward

compatibility or data migrations — the default is neither: hard

cutovers, no compat shims, no migration scaffolding, no deploy-order

dances. Only the user opting in puts them in the plan.

• Slice at API seams. Each slice should behave like a tiny library where

possible: named module boundary, typed inputs/outputs, deterministic

fixtures, and tests at the seam. If a slice needs three unrelated systems

booted before it can be checked, sharpen the seam.

• Research the fog. When the feature depends on an unfamiliar domain,

high-fidelity visual target, named reference, benchmark, external repo,

library, or "how do people usually do this?" question, do targeted online

research before finalizing slices. Prefer primary sources: official docs,

source repos, papers, case studies, talks, and shipped examples. If a

reference implementation exists, add a replication spike before translation

or approximation.

• Make progress visible. For visual or interactive work, every slice

should produce something playable: a route, fixture page, harness, CLI

probe, or HTML visualization the human can run, inspect, screenshot, and

critique. Tests prove contracts; demos expose taste and intent.

• Optimize feedback loops. Slice so the next useful question can be

answered quickly. Prefer tiny runnable surfaces, hot-reloadable harnesses,

sample fixtures, and self-contained workbenches over plans that require the

whole feature to exist before anyone can learn from it. For asset-heavy

work, plan an asset app/workbench where humans and artists can add samples,

upload replacements, preview them live, and see validation failures fast.

• Use the repo's natural shape. If the repo is a monorepo, plan apps and

packages instead of forcing everything into the current app. Give each

testable surface a first-class route or command; avoid piling new behavior

behind opaque query flags when a small dedicated app would be clearer.

• Do not block on missing inputs. If art, data, credentials, or external

assets are missing, plan generated placeholders plus a replacement contract.

The feature should advance with placeholders, while a separate handoff path

explains exactly what the human or external partner must provide later.

• Draft in parallel, then synthesize. For any multi-slice feature, don't

trust one pass to find the right cut. Fan out a few independent drafts and

merge the best into one plan (see the Workflow). Divergence is the point —

so engineer it on two axes: give each draft a different *bias* (a lens it

optimizes for) and, when more than one model family is available, a mix of

*models*. Blind, differently-biased drafts surface slices, seams, and risks

a lone plan misses — and where they independently agree, you know the cut

is solid.

• Recursively uncover fog of war. The first slice graph is a scouting pass,

not proof the field is known. After drafting, inspect each high-risk slice as

if it were its own feature. If it hides multiple variables, unknown external

practice, unproven architecture, or "we'll figure it out during

implementation," reslice that subset and repeat until every next slice has

one question, one seam, one review surface, and one verdict.

10. One visual variable per slice. Visual slices fail when they ask one pass

to match the final hero image. Split by the thing being judged: density,

silhouette, colour, texture, lighting, fog, water placement, water material,

label legibility, animation rhythm. Each slice gets a crop/mask and a verdict

for that variable only. Whole-frame comparison belongs at compose/integration,

after the variables have their own evidence.

Workflow

• Interview: keep asking until you can name the slices without

hand-waving. Stop when remaining unknowns can safely be discovered by the

first slice.

• Research: inspect the repo and research unfamiliar external practice

before drafting when the feature names a reference, library, technique,

standard, visual target, or performance pattern. Capture the discovered

source/repo/article/paper links in the spec and turn any exemplar into a

reproduction spike before a porting slice.

• Draft in parallel: for a multi-slice feature, spawn **at least three

independent subagents** to draft the whole plan — fresh context each, a git

worktree apiece if they must run or build to validate, otherwise have them

return the plan inline. Three is the floor, not the count: scale the pool

with the feature's complexity, adding a drafter for each genuinely distinct

approach or lens the problem supports. Give each the *same* brief from the

interview and nothing else (never another draft) — but assign each a

distinct bias so their divergence is structured, not accidental. The

baseline trio:

• A — fewest-slices bias: the smallest ladder that still ships; merge

slices aggressively, question every rung.

• B — risk-first bias: front-load the scariest unknowns; order slices so

the plan dies fast if an assumption is wrong.

• C — seam-quality bias: optimize API boundaries, ownership, and

testability at each seam, even at the cost of more slices.

Swap in or add lenses when the feature demands them (e.g. asset-pipeline

bias, perf bias, migration-safety bias), but keep the biases orthogonal —

grow the pool by adding a new lens, never by running the same lens twice.

Also mix model families: if you're currently instructed to draft with

codex, run at least one draft with claude — and vice versa — so the pool

balances different models' blind spots, not just different prompts. Family

means vendor (claude vs codex), not tier: every draft uses a

state-of-the-art model; never diversify by dropping to a weaker tier of the

same family. Each drafter: recon the real code and tests (measured facts,

failed approaches, scope firewalls, greppable file/test names), then propose

the slice graph, package/app boundaries, dependencies, API seams, playable

deliverables, verification gates, and human review checkpoints. Skip the

fan-out only for a genuinely single-slice problem.

• Synthesize: read every draft and build the canonical plan yourself —

don't anoint one. Take the strongest slicing, union the seams, risks, and

firewalls each caught alone, and where drafts disagree pick the

better-justified call and record the genuine alternative for the human. Where

the drafts independently agree you're on firm ground; where they split is

where to think hardest. When the feature has any visual surface, make

screenshot-critique a standing

verification gate in the README so every visual slice inherits it: the spec

must tell the implementing agent to run an unbiased screenshot-critique as the

last check on any visual shot before accepting it. Whenever a slice has

something to compare its shot against — a prior look it changes, or a

reference/inspiration image added for the feature — the spec must also name

compare-screenshots as the gate

that judges candidate-against-target: the telemetry and less-wrong verdict

that screenshot-critique's single-shot eyes do not give.

• Recursive fog audit: review the canonical graph slice by slice. For any

slice with hidden variables, broad verbs ("make it realistic", "match the

reference", "add the backend"), missing research, or more than one visual

variable/API seam, run this same slicing logic on that slice as a sub-feature.

Keep repeating until the next implementation slice can be accepted or rejected

by one focused artifact. Record deferred variables as later slices, not prose

inside the current slice. The exit test is the decision budget: a slice is

fully specified when the implementing agent inherits decisions rather than

making them — every freedom left open is either named as delegated in the

slice file or the slice needs another pass.

• Materialize: create specs/<feature>/ when the feature has more than

one slice or needs assets/visualizations.

• Refactor-clean the plan: run refactor-clean

over the materialized spec — the plan is architecture too, and it must describe

the shape the codebase would want if designed today, not the old shape with the

feature bolted on. Name each concept that should have one owner (projection,

environment, data contract, renderer phase, state machine, test oracle) and

confirm no slice introduces a parallel abstraction, duplicated concept, or

compatibility layer that a later slice must delete. Any transitional scaffolding

a slice genuinely needs must be named as a short-lived seam with an explicit

removal condition and the slice that removes it — collapsed the instant its

consumers migrate, never carried to the end by default. Encode the resulting

single-owner invariants and the end-state ("reads as designed today, not tacked

on") in the README so every implementing pass inherits them.

• Scrollback audit: the conversation dies; the spec survives. Before

calling the plan done, sweep the full conversation and every earlier

planning artifact (maps, interview notes, drafts) for content that exists

only there — decisions with their rationale, rejected alternatives with

why they lost, mid-stream scope changes, user-supplied constraints and

throwaway remarks that decided something. Each either lands in its owning

spec file or is deliberately dropped; a scope change propagates to every

spot that references it, not just where it landed. Then re-read each

surviving pre-plan artifact the spec supersedes (a map's kickoff prompt,

open-questions list, or proposed plan) and mark superseded sections with

a pointer to the plan — stale instructions must not be able to misroute a

fresh agent. Done when every conversation decision is findable in the

spec and no surviving artifact contradicts the ladder.

• Build slice by slice: leave each slice with a runnable artifact and

verification before depending on it. Keep each artifact small enough to

iterate on quickly. Keep the README's "Next Agent Prompt" written as the

handoff text a future agent should read and follow.

10. Reslice when the work says so: if implementation hits a snag and the slice

starts changing unrelated variables — or the choices ledger keeps filling

from one slice — stop broadening the patch. Update the spec

first: split the slice into smaller contracts, name the frozen inputs, move the

extra visual variables to later slices, and rewrite the Next Agent Prompt to

resume from the first new slice. Then continue. Reslicing is progress, not

failure.

Plan Folder

Use specs/<feature>.md only for a small, single-slice problem. Large

features live in:

• specs/<feature>/README.md — goal, context, slice graph, review map,

contracts, firewalls, known unknowns, and a "Next Agent Prompt" section with

the current status, next pickup point, global TODO checklist, and handoff

instructions for the next pass.

• specs/<feature>/slices/<NN>-<name>.md — one independently verifiable

slice per file.

• specs/<feature>/visualizations/*.html — roadmap diagrams, prototypes,

harness mockups, generated reports, contact sheets, or other

human-reviewable artifacts.

• specs/<feature>/assets/ — reference images, fixtures, captures, and other

inputs needed to judge the work.

For visual work, keep feature-owned visual evidence in the spec folder:

inspiration images, reference screenshots, archived baselines, comparison

contact sheets, generated candidate captures, and critique artifacts. If those

files start outside the spec folder, copy them into the spec folder when they

become part of the feature's review context. Product snapshot folders may still

hold the active regression baselines their harnesses own, but do not rely on

those mutable outputs or external paths as the only record of what the feature

was judged against.

Slice File Contract

Each slice file answers:

• What contract does this unlock?
• What is the API seam: module, functions/types, data shape, ownership?
• What can the human run or see?
• What tests, scenarios, screenshots, probes, or perf gates verify it?
• If the slice produces any visual shot (screenshot, GIF, contact sheet, or

on-screen render), the slice file must instruct the implementing agent to run

screenshot-critique as the last

check before the slice is accepted — an unprimed second opinion the regression

gates and the implementer's own inspection cannot supply. Write this as an

explicit verification step in the slice, not as a passing mention.

• If the slice's shot has a target to compare against — a prior look it changes,

or a reference/inspiration image added for the feature — the slice file must

also instruct the agent to use

compare-screenshots to judge

candidate-against-target: telemetry plus a less-wrong verdict, not a check that

the shot matches the reference. Write it as an explicit step too.

• For visual slices with a reference image, state the slice variable and the

crop/mask used to judge it. Also list visible wrongness that is explicitly

out of scope. Example: a grass-density slice compares lower-third coverage and

falloff only; cliff shape, cliff texture, water, sky, and fog are later slices.

A cliff-silhouette slice compares the ridge outline and depth rows only; rock

texture and haze are later slices.

• What decisions are delegated to the implementer? Name the freedoms

deliberately left open (internal structure, naming, reversible cosmetic

calls). Everything else must be resolved by the slice: an unlisted decision

the implementer has to invent is a spec gap that lands in the choices ledger

(audit-choices), not implementer discretion.

• What must stay green?
• What feedback from the human would change this slice?
• If the slice has a human review checkpoint, the slice file must frame it as

non-blocking: tell the implementing agent to open the shots for the user

with preview-shots, give a short window

(~5 min) for a response, and — if the user stays silent — decide on the

evidence, record the decision and rationale in the spec, close the opened shots

(preview-shots cleans up Preview, so an overnight run never piles up windows),

and proceed. Implementation never stalls waiting on sign-off; the checkpoint is

a chance to course-correct a reversible call, not a gate that blocks the build.

README Handoff Prompt

Every multi-slice spec README needs a "Next Agent Prompt" near the top. Write it

in second person, as the prompt a future agent should read when they resume the

feature. The README should not merely describe that it is live handoff state;

the section itself must directly tell the next agent what to do next. It should

include:

• Current status and last-updated date.
• The exact next pickup point.
• Active blockers or warnings.
• A global TODO checklist, with each item pointing to the owning slice.
• A direct instruction to the next agent to update this section before ending

their pass.

The point is that a fresh agent can open the README and know what to do next

without reading the chat.

Done

The feature plan is done when a fresh agent can start at slice 1 without the

conversation, and the human can review the roadmap without reverse-engineering

a wall of text.

Once the slices have all shipped, close-spec archives

the plan to specs/done/ and rewrites it from a build ladder into a durable

rationale record.