Spec-Driven Development With AI Coding Agents

What spec-driven development is, and what distinguishes it from a design doc

AI coding agents write fast, and they sound sure of themselves the whole time. That's the actual danger. Tell one to "add login," and it hands back working code that quietly drifts from what the team meant, and nobody notices until it's in production. Spec-driven development fixes this by making a written, versioned spec the thing everyone checks against, human and agent alike, instead of trusting the code to carry the truth on its own.

For decades, code has been the source of truth. Someone writes a design doc in week one. The team nods at it in the kickoff meeting. By week three it's stale, nobody opens it again, and the code marches on without it, the way it always has.

SDD flips that order. The spec lives in the repo, gets updated as the project changes, and code gets built (or rebuilt) from it. A phrase that has gained traction in 2025-2026 writing on this methodology captures it directly: the spec is the prompt. Not a reference document off to the side. The actual instruction set the agent runs on.

That distinction matters more than it sounds like it should. A design doc gets read by a person, maybe, if they remember it exists. It's advisory. Nothing breaks when it goes stale, because nothing was ever wired to check it against reality.

An SDD spec is executable. Tests fail when code drifts from it, and the checking happens continuously inside CI/CD, not once at a kickoff meeting nobody remembers by sprint three. A paper on this exact shift, "From Code to Contract in the Age of AI Coding Assistants," said it in one line: traditional specs are read by humans, while SDD specs execute as validation gates. One's a suggestion. The other is a gate the code has to physically pass through before it ships.

Why 2025–2026 made this methodology urgent rather than optional

This stopped being optional the moment AI-generated code became the default instead of the exception. A survey of 1,149 respondents on the state of code development in 2026 found that 42% of code in production is now generated or assisted by a model. Nearly half the codebase runs through a system with no built-in sense of what the team actually wants, and that's not a side project anymore. That's the main event.

Gartner's August 2025 forecast shows the scale compounding: 40% of enterprise applications will have task-specific AI agents embedded by the end of 2026, up from under 5% in 2025. Once agents sit inside that many applications, sloppy output is no longer one developer's bad Tuesday; it becomes a company-wide liability.

Left unchecked, the output is not clean, and the numbers sting. Sonar ran 4,442 Java coding assignments through five different large language models and found working code sitting right next to bugs, security holes, and code smells, over and over, in every model tested. Some of the holes were serious: 70.7% of the vulnerabilities Llama 3.2 90B produced were rated BLOCKER severity, GPT-4o came in at 62.5%, and OpenCoder-8B landed at 64.2%. Across the SecurityEval and SecCodePLT benchmarks, LLMs generated vulnerable code somewhere between 9.8% and 42.1% of the time, depending on the model and the task.

None of this is a new failure mode. It's the old problem of underspecified requests, scaled to a volume no human review process was ever built to catch. What changed is that a model, unlike a junior developer, won't stop and ask a clarifying question unless a process forces it to. It writes something plausible and keeps moving, confidence fully intact, accuracy optional.

The canonical SDD workflow: Specify, Plan, Tasks, Implement

SDD runs as a loop that stays alive. Specs get updated as requirements shift, and agents keep executing against the current version, never some frozen doc from three sprints back. Every major SDD tool runs some version of the same pipeline, and the order of operations is the whole point.

It starts with the Constitution: project-wide rules the agent has to follow no matter what, covering language choice, frameworks, testing standards, approved dependencies. AGENTS.md has emerged as a widely adopted convention here, a file that gives any coding agent the same baseline context no matter which tool is running it.

Then comes Specify, which covers what and why: user stories, acceptance criteria, nothing about implementation yet. Clarify follows, where the agent surfaces anything ambiguous before planning starts, so gaps get caught early instead of six files deep into a bad assumption. Plan handles the how (architecture, data models, technical tradeoffs), and Tasks breaks that plan into pieces small enough to ship and check on their own. Implement is where the agent actually writes code, checking each task against its own acceptance criteria as it goes. Analyze closes the loop, cross-checking that the spec, the plan, and the tasks still agree with each other.

One rule holds the whole thing together: never let an agent jump from spec straight to code. If you skip the plan and task breakdown, what you're running is vibe coding with extra paperwork stapled on. It looks disciplined. It isn't disciplined. The human review gate at each phase boundary is the thing that actually stops drift, not the paperwork itself, and teams that treat the gate as optional are the ones who find out six hours of code was built on a bad assumption nobody caught.

Addy Osmani at Google has described starting by brainstorming the spec with the AI itself, iteratively, asking it to poke holes and surface edge cases before anything gets locked down. Only after that back-and-forth does everything compile into one spec.md: requirements, architecture decisions, data models, and a testing strategy, all in one place. Nobody writes a line of implementation code until that document exists. Full stop.

EARS notation: the requirements syntax that makes specs machine-readable

None of this works if the requirements themselves leave wiggle room, and that's the gap EARS closes. EARS stands for Easy Approach to Requirements Syntax. Alistair Mavin and colleagues at Rolls-Royce developed it, published it in 2009, and presented it at the IEEE Requirements Engineering conference that same year. The paper's been cited more than 500 times since, mostly by people who never imagined it would end up steering a coding agent instead of a jet engine spec.

For about fifteen years, EARS lived quietly inside systems engineering, the discipline that writes requirements for jet engines and medical devices, where a bad requirement means someone gets hurt, not just a support ticket. Nobody wrote it with AI in mind.

It's back because AI coding agents need what EARS was built to enforce. EARS gives five sentence templates, and each one forces you to name the trigger, the system, and the exact behavior required. No exceptions. Try writing "the system should handle errors gracefully" in EARS. You can't. The grammar won't let you. You have to say which error, which component catches it, and what happens next, in that order, every time.

That precision was good practice back when the reader was a human engineer double-checking a colleague's work. When the same line is handed to an agent generating code straight from it, that precision makes the output match what the team meant, instead of whatever the model guessed was probably close enough.

The six major SDD tools in 2026, and what each one solves

Picking the right SDD tool comes down to one question, and it has nothing to do with feature lists: does the org need specs as static planning documents, or as live infrastructure coordinating agents across the whole software lifecycle? Get that question wrong, and every other comparison in the market is noise.

Two tools make the tradeoff obvious, because they're solving close to opposite problems.

Augment Cosmos is built for engineering teams juggling complex, multi-service codebases, where specs need to stay synced across team lines and the full SDLC. It's a cloud agent platform that launched in May 2026, and it operates at the level of an entire organization rather than a single workspace. It ships with reference Experts (Deep Code Review, PR Author, E2E Testing, Incident Response), all running on a Context Engine that holds semantic understanding across more than 400,000 files at once.

The Organization Knowledge layer is what actually sets it apart. Learnings carry across sessions, so an architectural decision one agent makes gets inherited automatically by agents working weeks later. A static-spec tool cannot do that by design, no matter how well built it is. Specs stay live too: if an implementing agent changes an API response shape, the spec updates immediately, and downstream agents read the new contract instead of the stale one. It also wires into event triggers from GitHub, Linear, Slack, and PagerDuty. Pricing runs $100 a month flat on the Business plan (up to 50 seats, with $100 of monthly usage included), or custom pricing for Enterprise.

It's a young platform still finding its footing, and independent third-party benchmarks are thin so far. The fit is obvious for teams running multiple services who need specs that don't go stale and agents that remember what happened last week. A solo developer on a single repo doesn't need this much platform. Paying for it would be like renting a forklift to move one bookshelf.

GitHub Spec Kit solves a different problem entirely: vendor lock-in. It's open-source under an MIT license, released September 2, 2025, authored by Den Delimarsky, a Principal Product Engineer at GitHub. GitHub frames it as an experiment, a way to test how far SDD methodology actually holds up once real teams start leaning on it.

Version 0.9.5 landed in early June 2026 as a major milestone, and the project passed 111,000 GitHub stars by that point, later climbing past 132,000. It hit version 1.0 on August 21, 2026. It runs through CLI commands and slash commands, and works across more than 30 AI coding agents, including GitHub Copilot, Claude Code, and Gemini CLI, with no lock-in to any single one.

The process is heavy, and the documents it produces govern code by convention, not by enforcement. Nothing stops an implementation from quietly drifting away from its own spec, and the tool has no built-in way to catch it when that happens. Cosmos updates the contract the moment drift occurs. Spec Kit just trusts the team to notice. Even so, for a team that wants the reference implementation of SDD, portable across whatever agent they're using this year and whatever they switch to next year, without paying for a platform, Spec Kit is the obvious place to start, and probably the only one worth trying first.