There is a reason "just prompt it better" stopped being a sufficient answer, and it is not that the models got worse.
A prompt is a request. A specification is a contract. The difference is not stylistic — it is that only one of them can be reviewed, executed, and held against the thing that was supposed to satisfy it.
The review arithmetic
Here is the situation the whole industry is currently in.
Writing the first version of a service that reads a CSV, exposes four endpoints and handles the obvious error cases takes minutes. That is real progress. It has moved the bottleneck somewhere uncomfortable.
The bottleneck is now review. And review has a bad property: its cost is proportional to volume, not to effort. A reviewer who does not trust the output has to read all of it. A 400-line diff that is 95% correct still requires reading 400 lines to find the other 5%. Attention does not scale with confidence.
Meanwhile the thing that determines whether the software is right — the requirement — is the thing nobody writes down. It lives in a chat message, a ticket title, and the reviewer’s recollection of a conversation three weeks ago.
Why a prompt cannot be reviewed
You cannot review a prompt, because a prompt does not say what you are getting.
The same prompt produces different implementations. The differences are invisible until you read the output, and once you have read the output, you are doing exactly the code review you were trying to avoid. The prompt did not save you anything; it moved the surprise to the end.
You also cannot diff a prompt usefully. "What changed since last time?" has no answer when the input was a paragraph of English and the output was four hundred lines of code.
And you cannot execute a prompt. There is no way to say "this prompt is now the definition of done" and then check it.
What a specification buys
The moment the requirement is a document, three things become possible that were not possible before.
It can be diffed. The review is "what changed since I last looked", which is a much smaller question than "is this correct". Most of the specification is not re-read; it is re-checked.
It can be decomposed. A specification has clauses. Each clause can be approved, rejected, or deferred independently. Rejecting one regenerates one. In a prompt-based workflow, the unit of work is the whole request, so the unit of feedback is the whole output — which means every rejection costs you a full regeneration and a full re-review. This is why people stop rejecting and start approving hopefully.
It can be executed. Once the requirement is a document, it can be checked mechanically. Lint it, type-check the implementation against it, verify that the two halves agree, and run it. The correctness argument stops depending on how carefully a human read a diff on a Friday afternoon.
The part people are uncomfortable about
None of this removes the need for human judgement. It relocates it.
Judging whether a clause is correct requires knowing the domain. There is no way around that, and any platform that claims otherwise is selling something. But the shape of the judgement changes, and the change is favourable:
- Judging intent is fast, and it is the judgement you are actually qualified to make.
- Judging implementation is slow, and it is the judgement that is best delegated to a machine that does not get tired, distracted, or socially reluctant.
The economics work out when the specification is short enough to review properly. Which is a discipline, not a feature — and it is the discipline most likely to be skipped, which is why we measure review time per clause rather than per specification.
The failure mode to watch for
There is a way this goes wrong, and it is worth naming before it happens.
If the specification is generated and then approved in bulk, you have moved the lottery rather than removed it. The output will be internally consistent, well-structured, and wrong in ways nobody checked. The review becomes a formality, and the formality is more dangerous than no review at all, because it produces a green tick.
So the platform does not let the coverage number stand alone. Every scenario carries an assertion-strength grade, and the completion map shows coverage and strength together. A specification that was approved without being read looks different from one that was reviewed — not because we assume good intentions, but because there is measurable evidence either way.
That is the whole argument. Not that a specification is automatically better. That a specification is reviewable, and reviewability is the only property that makes the rest of it work.
More on this in spec-driven development versus BDD, where the objections are taken seriously rather than waved away.