First-party only — a session id and where you arrived from, so we can tell which pages are worth writing more of. No advertising, no third-party trackers, nothing that follows you off this site.
The chained prompts that take a one-line idea to a reviewed pull request.
Agents fail on ambiguity long before they fail on syntax. This is the pipeline that removes the ambiguity first: a sequence of prompts that turns a vague request into a written spec, the spec into a plan, the plan into an implementation, and the implementation into something a reviewer will actually approve — with an explicit gate between each stage.
One-time. Yours permanently, including every future update.
You’ll enter your email first — a purchase has to be attached to an account so it does not get lost. It takes about fifteen seconds and brings you straight back here.
Nothing is hidden until after you pay. This is the complete contents. Files marked readable can be opened in full right now, without an account.
The shape of the pipeline, the two gates, and when not to use it.
Nine prompts. Paste, fill in the bracketed part, read the output, decide whether to continue.
Is this one task? What is the smallest useful version? Is the pipeline even worth it?
Write down what correct means. The adversarial decision-surfacing prompt.
Blast radius, irreversible steps, deploy ordering, failure modes, load, security.
Ordered steps, each independently verifiable, tree green after every one.
Types, signatures and failing tests, no logic — the cheapest moment to change the shape.
One step per turn, verified between. The rule about never editing a test to make it pass.
Four adversarial passes in a fresh context that did not write the code.
Behaviour not coverage — plus the step that proves each new test is real.
A description that makes review easier, and the ship check that verifies rather than asserts.
The only two places a human has to think hard.
Checklists, send-it-back conditions, and what good looks like at each.
The artefacts the stages produce. Commit these next to the code — a spec in a chat window is not a spec.
Restatement, numbered behaviours, decision table, out of scope, verification map.
Files, ordered steps with verification, and the behaviour-to-proof table.
Including the line most descriptions omit: what was not verified.
Three real shapes of work, end to end. Read one before running the pipeline for the first time.
11 ambiguities caught, one authorisation surface avoided, one DoS found in review.
A one-sentence rename that became four deploys — and the three outages that did not happen.
19 decisions, a stored XSS found incidentally, and the two bugs backend review never catches.
For when stage 06 produced something wrong and you need to unwind cleanly.
Which kind of wrong, the two-turn unwind prompt, and keeping what you learned.
The nine stages, the rules that make it work, and when the pipeline is overhead. This is the actual file, not an excerpt.
# Spec-to-Ship
The chained prompts that take a one-line idea to a reviewed pull request.
Agents fail on ambiguity long before they fail on syntax. This pipeline
removes the ambiguity first, then keeps the work bounded stage by stage.
## The pipeline
01 Intake Is this one task? Is it clear? What is missing?
02 Spec Write down what "correct" means. Adversarially.
03 Risk pass What breaks that is not obviously related?
── GATE ── a human answers the open questions ──────────────
04 Plan Files, order, verification per step
05 Scaffold Types, signatures, failing tests — no logic
── GATE ── the shape is agreed before logic exists ─────────
06 Implement One step at a time, verified between
07 Self-review Four passes, adversarial, in a fresh context
08 Test backfill Behaviour, not coverage
09 PR writeup What changed, why, how it was verified
## Rules that make it work
**Each stage ends with output you read.** If you skip reading a stage's
output, delete that stage — it is costing tokens for nothing.
**Gates are where humans decide.** Two of them. Everything before gate 1 is
about surfacing decisions; nothing after gate 2 changes the shape.
**A new context per stage from 06 onward.** Carrying the spec conversation
into implementation is the single biggest cause of drift.
**Any stage can send you backwards.** Discovering in 06 that the spec was
wrong means going back to 02, not patching forward.
## When not to use this
Small changes. A typo fix, a one-line config change, a rename. The pipeline
is overhead below roughly "half a day of human work". Use `/repro` and a
scoped request instead.
## Using it
Each `pipeline/NN-*.md` is a prompt. Paste it, fill in the bracketed part,
read the output, decide whether to continue.
`templates/` holds the artefacts the stages produce — commit these to the
repo alongside the code. A spec that lives in a chat window is not a spec.
`examples/` walks three real shapes of work end to end. Read one before
running the pipeline for the first time; it is faster than reading the
stages in the abstract.
## Licence
Yours to use in any project, personal or commercial. Do not resell or
republish the files themselves.14-day refund, no explanation needed. If it does not earn its price, say so and we send the money back.