author · the code stage

AI writes it.
It doesn't get the last word.

Author is where the code gets written and reviewed as it goes, against a spec it has to answer to. This is the fast part. It just can't ship on faith.

See it check your own work →

the problem

AI saved you an hour. Review took it back.

The model writes a feature in seconds. Then a senior engineer spends the afternoon reading it, because nobody trusts what came out. The time you saved writing, you spend again checking. And things still slip through.

what it catches

One piece it leaned on never existed.

The code looks right. It imports a hook that was never real, traces to a slot on the reference that holds nothing, and a human review slides right past it. The check does not.

three imports trace to a real hook · the fourth traces to nothing

how it stays on contract

Gated, step by step.

written to the handover

Every change answers to the handover that came out of Capture. That is the sealed spec, with what "done" means already written into it. The model has a target it can be held to, not one it guesses at. See the handover →

checked at each step

Nothing advances until it passes. Nothing lands because it looked fine.

drift turned back

Anything that strays from the spec is refused before it hits your branch. The catch happens at commit, not in production.

a record of why

Every change traces back to the ask. When someone asks why the code is like this, there is an answer, and it is written down.

This is where the vibing happens. It's just bounded.

where the work happens

In your editor. Reviewed as you go.

Author runs where you already work. The model proposes a change, you run it, you see it, you change it. The difference is the review. It does not wait for a pull request at the end. Every step is checked against the spec the moment it's made, so the review keeps pace with the writing instead of piling up behind it.

propose

The model writes the next change against the spec, not against a vibe.

run and see

You run it and watch it work, in the editor you already have open. No context switch to decide whether to trust it.

reviewed at the step

The gate checks the change the moment it lands, not days later in someone's queue. Review is continuous, not a bottleneck at the end.

you keep the last word

You direct it, accept it, or turn it back. The speed is the model's. The call is yours.

why you can trust the catch

Whatever writes the code shares its blind spots.

A model that reviews its own output brings its own mistakes to the review. So the checks that catch drift are the ones that owe the code nothing. The maker writes it. A pilot re-checks every step against the contract. A watcher, outside the whole system, checks the pilot.

See the three checks →

what happens when it drifts

It doesn't paper over. It stops.

Most tools smooth a bad line into something that compiles and move on. Author does the opposite. When a change can't tie back to the spec, it halts, and that refusal is the point.

it halts

The step stops instead of shipping. Not a warning buried in a log. A hard stop, at the commit, before the branch ever sees it.

it names the reason

The refusal says what broke. The import that resolves to nothing, the change that touched a file it had no business in, the requirement it can no longer satisfy.

it repairs to real ground

The fix is not a better guess. The line is rewritten to something that actually exists, and the claim lands where you can check it.

or it escalates

If there is no honest repair, it comes back to you with the reason instead of inventing one. A stop you can act on beats a pass you can't trust.

where it sits

Author is one stage of five.

The spec it builds against comes from Capture. The checks it has to pass come from Rehearse. It is one stage on a track that runs from a rough ask to a proof at the end.

See the whole pipeline →

AI writes it.It doesn't get the last word.