Spec-driven development versus BDD

This is the guide people want and rarely find: an honest comparison between traditional BDD and spec-driven development, including the cases where the old objections still hold.

What actually changed

BDD’s original problem was communication, and it solved it. In 2006 the problem was that a stakeholder and a developer would use the same word — "refund" — to mean different things. Gherkin forced a shared vocabulary into a document both sides could read. That was a real problem with a real solution.

The new problem is review cost, and it is a different problem. With a capable coding model, implementation is cheap. The expensive step moved: reviewing a large generated diff takes as long as reading it, no matter how it was produced. And a specification is a much cheaper thing to review than a diff, because it is shorter, structured, and about intent rather than mechanics.

So the shift is not "BDD but with AI". It is:

BDD optimised the conversation between people before coding. Spec-driven development optimises the review of a machine-produced implementation after it exists.

Everything BDD was good at — shared vocabulary, examples as documentation, executable acceptance criteria — is still good and still applies. What is new is what sits on top of it.

Traditional BDD Spec-driven delivery
Who writes the spec The team, by hand The team, or a model as a draft
When the spec is written Before implementation Before implementation, still
What the spec is for Shared understanding Shared understanding and reviewable contract
Who writes the implementation The team The team, or a model
Review effort On the code On the spec, then mechanically on the code
Executable criteria Sometimes Always, and always executed
Cost of a missed requirement Found in production Found by the trial environment

The objections that still hold

"The team will not write specifications"

Correct, and the platform does not require it. The model drafts the specification. The team reviews it. The team’s job shifts from authoring to judging, which is a different skill and a smaller one — but it is still a job, and if nobody on the team can tell whether a clause is right, no platform can help.

The honest version of this objection is sharper: spec-driven delivery does not remove the need for domain expertise. It changes where it is applied. Instead of encoding expertise in implementation code, it is applied once, in a document, where it is cheaper to get right and cheaper to change.

"It will produce plausible but wrong output"

Also correct, and it is the objection that deserves the most attention — because the failure mode is invisible.

A generated specification can be internally consistent, well-formed, and wrong. It will pass every structural check. This is why the platform grades assertions for strength and reports escape rate from real defects, rather than relying on a coverage number. See assertion strength.

The strongest form of the objection is: a model that writes both the spec and the implementation will write tests that agree with the implementation. That is true, and it is the reason the specification is drafted separately, reviewed by a human, and then used as the sole input to verification. The verification must be able to disagree with the implementation, or it is not verification.

"This is just waterfall with extra steps"

Only if you write the specification once, at the start, and never revisit it. The workflow is a loop: a defect found in the trial regenerates the clause that should have caught it, and the specification gets better as the project proceeds.

A specification that is written once and treated as frozen is a document nobody reads. A specification that is updated when it turns out to be wrong is a living artefact — and that is the difference.

"The review moves, it does not shrink"

This is the sharpest objection, and the one worth taking seriously. It is possible to replace a code review with a spec review of the same or greater size, and end up with nothing gained.

The platform’s answer is measurement rather than assertion. The question is whether spec review takes less time than the code review it replaces, and that is measurable: review minutes per clause, against the equivalent baseline. If it is not smaller, the approach is not earning its place and should be abandoned.

That measurement is the pilot’s whole point, and it is the one number we would watch most closely.

When it is worth the switch

It is worth it when:

  • The behaviour has crisp, checkable outcomes.
  • Review is currently the bottleneck, rather than understanding the domain.
  • The same behaviour gets implemented more than once, in slightly different services.
  • The team already has some practice with Gherkin, or with contract-first design.
  • The cost of a production defect is high enough that mechanical verification pays for itself.

It is not worth it when:

  • The requirements are genuinely open-ended and will be discovered by building.
  • The domain cannot be stated precisely — where nobody agrees on what correct means.
  • The work is mostly UI.
  • The team’s real problem is unclear requirements, not expensive review.

That last pair is worth stating plainly. If the problem is that people do not know what to build, a specification platform makes that visible faster, but it does not solve it. It gives you a document to disagree about, which is genuinely useful, and it stops there.

A migration path that works

Do not convert everything.

  • Pick one behaviour with a crisp outcome that the team already argues about.
  • Write the spec by hand — a feature file, in the style you want.
  • Let the platform draft the implementation from it.
  • Compare the review times. Spec review against the code review it replaces.
  • If it wins, expand by one more behaviour. If it does not, stop, and keep the feature file — it is still a better artefact than a ticket.

Teams that try to convert everything at once end up with a specification nobody reads, and conclude the approach does not work. Teams that convert one behaviour learn something useful in a week.

What we do not claim

We do not claim that spec-driven development replaces code review. It replaces reading code you did not write. Code review remains essential — for design, for structure, for the parts of the implementation the specification cannot constrain.

What changes is the ratio. You spend your attention on intent, and the mechanical part gets checked by machines that will do it more consistently than a tired human on a Friday afternoon.