For years you got one or the other. Slow work you could prove, or fast work
you couldn't. AI made everyone fast. It made no one sure. CRAFT is the first way that doesn't make you choose.
then
Slow, and sure. You could prove every line. It took forever.
now
Fast, and blind. Code in seconds, and no one can say why it works.
with CRAFT
Fast, and sure. The speed of now, with an answer for every line.
A river runs fast because it has banks. Take them away and you get a swamp.
the five stages
One track. The ask goes in. Proof comes out.
Each letter is a stage. Each one passes before the next opens. The work moves
along the track. Underneath it, the same spec holds every step to what was agreed.
the ask enters once · every gate checks the same spec · nothing advances until it holds
what each stage does
Five stages. One contract.
C. Capture
A rough ask becomes a spec you can read and check. The requirements, the numbers that matter,
the shape of the thing. Anything vague gets named as vague. Nothing slips through as an assumption.
See the spec →
R. Rehearse
The spec becomes checks that decide pass or fail, before a line is written. You settle what
"done" means up front, so the work has something real to answer to.
See the checks →
A. Author
Code gets written against the spec in your editor, one gated step at a time, and reviewed as
it's written, not days later in a queue. This is the fast part. Anything that drifts is turned back before it
hits your branch. See how the code stays on contract →
F. Field
It goes live under rules read straight from the spec. Not written a second time by hand and
hoped to match. See the deploy stage →
T. Track
Every target you set at Capture gets a live signal in production. What you promised is what
you watch. See the signals →
under the surface
Five stages you see. Hundreds of checks you don't.
Each stage is not one step. It is dozens of small, specific checks that run on
their own, and the deeper build path runs deeper still. You see five clean stages. Underneath, the same spec
holds hundreds of moving parts in line at once.
The simplicity is the interface. The rigor is underneath.
why it is one thing
The same spec runs the whole way.
Capture writes the spec. Author builds against that same spec, Field deploys
it, and Track watches it. So "reset completes under two seconds," written once at the start, is the check the
code must pass, the setting the deploy reads, and the signal you watch in production. One line, the whole way.
The proposal you hand a client and the code you ship come from one source, and they don't drift apart the week
the deal is signed.
The spec you bid is the spec you build.
Every step is checked three times. By three things that each owe the others
nothing.
the maker
Makes the work, and checks itself as it goes. An honest first pass. It still can't see its own
blind spots.
the pilot
Re-checks every step against the contract. It passes nothing it can't tie back to what
was agreed.
the watcher
Sits outside the whole system. It answers to the contract, not the pilot. It holds back
anything that can't show it followed the spec. See the three checks →
where you start
Start where you are.
You don't have to start at the beginning. Start with what's already in your
hands.
I have a document
"We lose the bids we should win, and win the ones we can't deliver at the price we quoted."
An RFP, an SOW or a brief becomes a spec you can audit and a dossier you can defend, with every estimate tied
to a named requirement. For solution & delivery teams →
I have an idea
"I don't know if this is worth building, and every AI tool just tells me yes."
A raw idea gets an honest read, a pursue, pivot or kill verdict, and a buildable spec if it says go.
For founders →
I have a codebase
"AI writes it in seconds, then we spend everything we saved reviewing it."
Code gets written against the spec, one gated step at a time, and anything that drifts is refused at the
commit. For engineering teams →