There's a reflex reaction when developers first hear about Spec-Driven Development: "Great, we're going back to Waterfall." The comparison is understandable — and worth taking seriously before dismissing it.
The surface similarity is real
Why It Feels Like Waterfall
In both Waterfall and SDD, you write documents before you write code. In both, those documents have names like "requirements" and "design." In both, someone has to sign off on a plan before implementation starts. For anyone who lived through the 1990s and early 2000s, when Waterfall produced three-ring binders nobody read and projects that shipped two years late and wrong, that pattern recognition is visceral.
But Waterfall wasn't killed by the documents. It was killed by two specific assumptions baked into its DNA: that requirements can be complete before implementation starts, and that deviations from the spec are failures rather than learning. The spec was a contract. Change was a breach.
Those assumptions are gone in SDD. The spec is a starting position, not a contract. It exists to be amended when reality diverges from the plan — and it will. The question isn't whether the spec will change; it's how quickly you can update it when it does, and whether the implementation drifts silently or the drift is captured and deliberate.
The feedback loop has changed everything
There's a critical structural difference that wasn't available in the Waterfall era: the thing reading your spec is not a team of twenty engineers in a six-month project. It's an LLM working in hours. The feedback loop between spec and output is tight enough that "iterate on the spec" is a reasonable thing to do in the same afternoon.
Waterfall's rigidity was partly a response to the cost of iteration — when it took a month to incorporate feedback, you didn't want to incorporate it often. That cost is gone now.
So yes, SDD puts documents before code. No, it is not Waterfall.
The convergence isn't coincidental
The Industry Is Reaching the Same Conclusion
This isn't a fringe practice anymore. In 2026, every major AI coding tool has shipped its own flavor of spec-driven development. GitHub shipped Spec Kit. AWS launched Kiro, an entirely new agentic IDE whose core differentiator is that before any code is written, the agent produces three structured documents: requirements.md, design.md, and tasks.md. Cursor, OpenSpec, BMAD, Tessl — the list is past thirty frameworks and growing. A recent survey of agentic coding tools called it flatly: "SDD is eating software engineering."
The convergence makes sense. Every team that gave an LLM a vague prompt and watched it build something adjacent to what they wanted eventually arrived at the same place: the model needs more constraint, not more capability. The problem isn't that the model is too dumb to build the right thing — it's that "the right thing" was never specified precisely enough to leave room for a wrong answer.
Early adopters at GitHub and AWS are reporting 3–10x higher first-pass success rates from agents on non-trivial tasks when working from structured specs. That's not a small number.
Capability and reliability don't scale together
Agents Are Getting Better. Phases Still Matter.
Here's where it gets interesting — and where the Waterfall parallel gets tempting again.
AI agents are improving at long-horizon tasks at a remarkable rate. Research from METR shows AI task duration doubling roughly every seven months. In early 2025, a capable agent could reliably handle about an hour of autonomous work. By late 2026, that's projected to stretch to eight hours. Claude Opus 4.8, released in early 2026, has a 1M-token context and a 14.5-hour task horizon. OpenAI Codex recently introduced a /goal command for persistent objectives that survive session breaks.
The natural reaction: if agents can now handle eight-hour workstreams, why break anything into phases at all? Just give the spec to the agent and go to lunch.
Task horizon vs. reliability: they don't scale together
The same METR research shows that every agent experiences a success rate drop past about 35 minutes, and doubling task duration roughly quadruples the failure rate. What you gain in raw capability you lose in consistency.
Context rot is the underlying mechanism: as the session gets long, the context window fills with error traces, failed attempts, and accumulated tool call history. The model starts making worse decisions — not because it forgot the spec, but because the signal-to-noise ratio in its working memory has degraded.
This is what practitioners call "context drift," and it's still an open problem in 2026. Getting agents to make consistent progress across multiple context windows — where the second session has no memory of what the first session tried and failed — remains one of the harder unsolved challenges in production agentic coding.
Phased implementation is the practical response. Not because agents can't handle long tasks, but because a hard checkpoint resets the context. Complete Phase 1. Validate: does docker compose up succeed? Does /health return 200? If yes, start a fresh session for Phase 2. Each phase's agent starts with clean context, anchored to the spec and the plan, without the accumulated noise of everything the previous session tried. You trade the theoretical efficiency of one giant session for the actual reliability of many short ones.
The agents will keep improving. The physics of context degradation are unlikely to disappear entirely. Phases will remain useful for the foreseeable future, even as the phases get longer.
The real job specs do
Specs Are Guardrails, Not Blueprints
Beyond the session management question, there's a more fundamental thing specs do that has nothing to do with Waterfall and everything to do with the specific failure mode of LLM-based development.
When vibecoding — prompting an agent to build something without constraints — the agent goes on tangents. It builds what you asked for (kind of), but it also builds abstractions you didn't want, implements features you didn't mention, and scaffolds infrastructure you weren't ready for. The bigger the task, the larger the diversion. The agent genuinely believes it's helping. Think of it like a junior developer who can't resist adding "just one more thing" — except the junior developer works at superhuman speed and generates a lot of "one more things" before you notice.
Specs curtail that. Not perfectly — the LLM still wants to show its potential. But with a spec in place, it doesn't drift nearly as far. The spec tells the model not just what to build, but what not to build. That framing is underappreciated.
The vibe coding hangover
Teams that built fast and loose in 2024–2025 are now dealing with PR review fatigue — a 40–60% increase in pull request volume with code that's hard to review because no one specified what it was supposed to do. The architectural drift compounds: the model forgets earlier decisions and contradicts them silently. What felt like productivity was often just deferring the reckoning.
In speckit, the guardrail mechanism is explicit: a project-level constitution.md with numbered principles in hard MUST language. During planning, every principle gets checked against the proposed design. Fail a gate, and the planner stops. The agent can't silently drift into an architectural decision that violates your explicit constraints — the fence is enforced programmatically rather than by hoping the model remembers your preferences from three sessions ago.
The honest limit
The 60–80% Problem
Specs will get you 60, maybe 80 percent of the way there. Getting to 100% with a spec alone is nearly impossible unless the problem is trivially simple.
What actually happens in practice: you use the spec to get close, then you iterate. You tweak the UI, refocus the logic, adjust behavior you didn't anticipate needing to define. And to be honest — not every change makes it back into the spec. If there's a major derailment, yes, you update the spec documents, plans, and tasks. But moving a button or changing a color? That usually goes undocumented. That's a pragmatic call, not a failure of the methodology.
This is the sharpest contrast with Waterfall. Waterfall treated every deviation as a defect requiring a change request. SDD distinguishes between deviations that matter architecturally and ones that don't. You don't need to document every UI tweak. You do need to document a change to the data model or the authentication strategy, because the next agent session — starting fresh, anchored to the spec — will contradict you if you don't.
The spec is a living document. It needs to stay close enough to the actual system that an agent reading it cold can make good decisions. Not completeness, not contractual accuracy — sufficient fidelity to guide the next session.
Lessons from using it wrong
The Steps Most People Skip
After experimenting with speckit seriously on a real project, I discovered I was using it wrong — and the mistakes were instructive.
The most underused step in the entire workflow is clarification. Speckit has a /speckit-clarify command that runs a taxonomy scan across eleven ambiguity categories and surfaces up to five questions per run, one at a time, each with a recommended answer — and you can re-run it as many times as you need until the spec feels tight. It's not interrogating you; it's proposing defaults and letting you validate or override. The questions it surfaces feel obvious in retrospect: "Should visibility inheritance cascade to federation nodes or only managed nodes?" "Should delete be leaf-only or support cascade?" These are the decisions that, when left unresolved at spec time, become architectural surprises during implementation — or worse, contradictory fix commits after the fact. Kiro takes a similar approach: before any code, the agent asks clarifying questions and resolves ambiguity in the design document, not in the middle of writing a migration.
The second most skipped step is cross-artifact analysis — mapping every requirement to a task and flagging zero-coverage gaps before implementation starts. This is not a review you do yourself; it's an automated pass that catches drift between what the spec promises and what the implementation plan actually covers. I skipped it. I paid for it later in fix commits that could have been caught in five minutes.
The consistent pattern
The steps that feel like overhead are the ones that prevent the expensive surprises downstream. This is the lesson Waterfall learned the hard way in the wrong direction — more process isn't always better — but SDD's feedback loop is tight enough that a little process upfront genuinely costs less than the cleanup after.
The actual value proposition
What SDD Actually Gives You
The real value isn't the documents. It's a forcing function for making decisions upfront that you'd otherwise make under pressure mid-implementation.
Waterfall tried to make those decisions comprehensive and final. SDD makes them sufficient and revisable. You define enough to constrain the work, and you update when reality diverges from the plan. The spec lives alongside the code, not above it.
The sessions that go best are the ones where the spec is treated as a living document — something to amend when you learn something new, not something to protect from reality. A spec is a fence. Build it thoughtfully, check it often, and adjust it when the terrain shifts.