Spec first, always

Nothing gets built from a conversation. A human writes the spec first: what to build, what it must not do, what done looks like. The agents work against that file. The spec is the control surface. Change the file and the work changes, and it is the only lever that outlives the session it was pulled in.

Every company using agents has written this rule down somewhere. Most have written it as advice. The version that holds is structural: the spec lives somewhere the agent must read and the human must edit, and the work cannot start before it exists.

Decision rights

The human decides what gets built and what done means. The agent decides how. That split is only real if the human's half is written down. Said in a session, it dies with the session, and the next agent starts from a blank slate and its own taste.

Escalation is the other half. Anything the spec does not cover stops the work. An agent that guesses is cheaper than one that asks, right up until you are reviewing the guess, and reviewing a wrong guess costs more than writing the missing line would have.

Memory and context

The spec is the memory. Agents start every session empty. Whatever the last one worked out lives in a file or it is gone. This is the layer people get wrong first, because the context feels present while the session is open.

Two places context goes to die. The conversation: worked out, agreed, never written, unrecoverable. And the code itself, where the decision survives only as its consequence and the next reader has to re-derive intent from a diff.

What earns a place in the spec is the constraint, not the conclusion. "We chose X" is a fact. "We chose X because Y broke on Z" is what stops the next agent proposing Y in three weeks, confidently, with a fresh context window. And a fact is stated in exactly one file and referenced from everywhere else. Two copies drift, and the agent reads whichever it hits first.

Execution

Below the spec line, latitude is wide on purpose. The spec bounds the blast radius. It does not prescribe method. An agent that has been told what the thing must do and what it must not touch can pick its own path through the middle.

One spec, one branch, one merge. A spec that produces a six-week branch is not a spec, it is a roadmap wearing the wrong label. Split it until each piece merges on its own.

Spec-first fails in one place: exploration. You cannot specify what you are still learning, and pretending otherwise produces a spec that describes your first guess. The honest shape there is a throwaway branch whose only output is the spec you could not write before. Then delete the code and build it properly against the spec it taught you.

Governance

The spec is what review is against. Without one, review is taste, and taste does not scale past the person holding it, which is exactly the constraint agents were supposed to remove.

The gate: every changed line traces to a line of spec. A change that does not is either scope creep or a missing spec line. Both stop the merge and both are fixed in the same order: spec first, then code. It sounds bureaucratic and takes about a minute in practice, because "which line asked for this?" is fast to answer and impossible to fake.

How much autonomy a task gets is a separate call, made on the autonomy ladder. This principle only says the ladder is climbed against a written spec rather than an intent someone remembers.

Observability

You can tell it is working when the review question changes. Without a spec you ask "is this good?", which has no end. With one you ask "does this match?", which ends.

The failures announce themselves, roughly in the order you see them. The same question asked twice by different agents: a gap the spec never closed, answer it in the file not in the reply. Two repos naming the same object differently: the spec did not own the name, so both minted one. A doc PR merging after the code PR it describes: that is documentation, not a spec. Documentation records what happened; a spec constrains what happens next. Only one of them is a control surface, and the cheapest test on this list is reading the merge order.

The audit trail is free. Because specs are files, "what did we decide and when" is a git log rather than someone's recollection.