# Spec-Driven Development is not Waterfall in a Hoodie

> Source: <https://martinelli.ch/spec-driven-development-is-not-waterfall-in-a-hoodie/>
> Published: 2026-11-16 08:16:29+00:00

Andrea Laforgia just published [Spec-driven development: Waterfall in a Hoodie](https://a4al6a.substack.com/p/spec-driven-development-waterfall). His claim: if a written spec must be approved before code is built and tested, we find wrong assumptions too late. That is the old Waterfall problem in new clothes.

I agree with much of what he writes. Feedback from working software is the most important feedback we have. Large batches get skimmed, not reviewed. And an AI agent can build a lot of code on top of a bad requirement before anyone notices.

But I don’t agree with the conclusion. The problem he describes is not the spec. It is the shape of the process around the spec. And spec-driven development does not have to look like that.

## The problem is batch size, not the spec

Waterfall did not fail because people wrote things down. It failed because they wrote everything down first, approved it all at once, and saw working software months later.

Many spec-driven tools repeat this shape: requirements, then plan, then tasks, then code, with an approval gate between each step. If the batch is a whole feature or a whole system, Andrea is right. You approve a lot of untested assumptions in one go.

Interestingly, Royce’s 1970 paper already warned against this staircase. And the Rational Unified Process was built as an answer to it: iterative, risk-driven, with working software in every iteration. The Unified Process was never Waterfall. It was the way out of Waterfall.

## Thin slices with the AI Unified Process

The AI Unified Process follows the same idea. The unit of work is one use case. There is no task layer in between. One iteration looks like this:

1. The domain expert writes or updates one use case: main success scenario, alternative flows, business rules.
2. Open questions are recorded in one central file. The agent does not guess.
3. The agent implements the use case and writes the tests.
4. A coverage check maps every step and every business rule to code and tests.
5. The team and the users try the running software. What they learn goes back into the spec.

This takes hours or a few days, not months. The spec is small, and it meets reality quickly. That is very close to what Andrea calls short intent and thin slices. The difference is that the intent does not disappear after the iteration. It stays as a living description of what the system does and why.

## Passing Andrea’s three tests

Andrea gives three tests for a living spec. They are good tests, so let’s use them.

| Test | How the AI Unified Process answers it | 
|---|---|
| Can we test an assumption soon? | Yes. One use case per iteration, running software in hours or days. | 
| Is the change to test a revision small? | Yes. You change one scenario step or one business rule, and the agent updates code and tests. | 
| Do we avoid keeping two descriptions in sync? | The coverage check links each step and rule to code and tests, so drift becomes visible instead of silent. | 

### “No gap” is the wrong promise

On one point I fully agree with him. Generating code from a spec does not prove the code matches the spec. And matching the spec does not prove that users get what they need. His refund example shows this well: all tests pass, but nobody asked about partial refunds.

That is why the AI Unified Process does not promise “no gap”. It makes the gap visible. Unclear points become open questions before implementation. Coverage checks show what is not implemented or not tested. And user feedback on the running software is part of every iteration. A missing alternative flow like partial refunds is exactly what a good use case review finds, because alternative flows are a fixed part of every use case.

## Conclusion

Andrea asks us to judge a process by how fast it exposes wrong assumptions and how little must change when it does. I like that measure, and I think spec-driven development can pass it.

The question is not “spec or no spec”. The question is batch size. Specify one use case, build it, test it, show it to users, learn, and repeat. Then the spec is not a Waterfall document. It is the shared memory of the team and the agents.

Without that memory, every new agent session starts from the code alone. And code tells you what the system does, but not why.

*Keep IT simple.*
