# Spec-Driven Development: what it is and why it is changing software

> Spec-Driven Development writes the specification first and lets AI generate the software against it. What it is, how it works and why it beats vibe coding.
> By José Maldonado · Artificial Intelligence · 2026-09-30

There are programs today that are born without anyone really writing a line by hand. Someone describes what they want, accepts every suggestion from the assistant and sends the errors back to the chat until the application works. That practice has had a name since Andrej Karpathy, co-founder of OpenAI and former director of AI at Tesla, christened it **"vibe coding"** in a message posted on X on February 2, 2025, in which he admitted forgetting that the code existed, as reported by [MIT Technology Review](https://www.technologyreview.com/2025/04/16/1115135/what-is-vibe-coding-exactly/). The coinage struck such a chord that Collins Dictionary chose it as its word of the year for 2025, as reported by the [BBC](https://www.bbc.com/news/articles/cpd2y053nleo).

Nineteen months after that message, the industry responded with a method that reverses the order. On September 2, 2025, GitHub presented its open source toolkit, [Spec Kit](https://github.com/github/spec-kit), which puts the specification at the center and lets the agent generate the implementation and the tasks from it, as it explained in its [official blog](https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/). The repository passed 100,000 stars in September 2026, a reception that reveals the hunger for order that was there.

The shift has measured reasons. Veracode analyzed more than 100 models across 80 tasks and found OWASP Top 10 flaws in 45% of the generated code, with Java above 70%, according to its [July 2025 report](https://www.veracode.com/resources/analyst-reports/2025-genai-code-security-report/). And a METR essay with 16 expert developers across 246 real tasks showed that using AI lengthened work by 19% on complex code, even though participants believed they had been 24% faster, according to [METR](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/).

The message is clear: programming by "feel" works for prototypes, but software that must last requires writing down what is wanted first and letting the code obey. But above all, it requires reviewing, testing and testing again, as it has always been.

## Spec-Driven Development: making "vibe coding" something serious

Think of ordering a cake on instinct versus ordering it with a recipe. With vibe coding you say make me a nice online store and accept whatever comes out. With Spec-Driven Development you write down the ingredients, the steps and the cooking point. A good specification details its pieces.

*   What is being built and what problem it solves, told from the user's perspective.
*   Main journeys and the outcomes that matter.
*   Acceptance criteria that mark each feature as passing.

GitHub sums up the shift with a direct image in its Spec Kit guide. For decades code was king and specifications were scaffolding thrown away when the work began, whereas now they become executable and generate implementations that obey them, as the Spec Kit documentation details. Code stops calling the shots and comes to serve the specification.

Anyone who defined an OpenAPI schema before programming the API was practicing this discipline without knowing it. The novelty is that the agent turns requirements into plans and plans into code, while the person directs, reviews and decides, with principles set out in a constitution file.

**You may be interested in: [Vitalik Buterin explains why Ethereum will be much more than a blockchain](https://observatorioblockchain.com/en/ethereum/ethereum-mas-que-blockchain-vitalik-buterin/)**

## How do you work with specifications and AI agents?

The usual flow chains together a journey that produces plain-text documents versioned with Git, where each phase feeds the next and nothing is decided twice in lost chat threads.

*   Define the what and the why with user stories.
*   Agree on the how with stack, architecture and constraints.
*   Break the plan into small, verifiable tasks.
*   With the plan settled, implement task by task with bounded review.

The commands direct the agent without typing out rituals. Each order generates Markdown files for the project that feed the next phase, with structured context instead of loose promises lost in the chat history.

Spec Kit provides commands such as /specify for the specification, /plan for the design and /tasks for the work list, plus /implement and /converge in its version 1.0, as explained by [Microsoft for developers](https://developer.microsoft.com/blog/spec-driven-development-spec-kit/). If something changes, the specification is edited and everything is regenerated from there; the generated code is never patched behind the document's back.

Amazon's variant follows the same logic with its own vocabulary. Kiro, for example, asks for requirements with acceptance criteria in EARS format, of the type when X occurs, the system shall do Y, and from there it produces design, correctness properties and tasks, as its principal engineer explained at [AI Engineer](https://ai.engineer/talks/HY_JyxAZsiE-spec-driven-development-agentic-coding-at-faang). Kiro adds steering documents, automatic hooks and MCP connection to bring in external documentation. The underlying idea is the same in both tools, because the developer conducts the orchestra and the agent plays the instruments, but the score calls the shots.

## Why does it work when vibe coding breaks down?

The key lies in the memory each method offers the model. A language model optimizes for the most plausible continuation of the immediate text, not for fidelity to an intention expressed twenty messages ago. Without a specification, each instruction renegotiates what has already been decided and the design drifts toward a different program from the one requested. With a specification, the intention is fixed in a persistent document that the agent consults at every step, and what is generated is checked against that text.

That anchoring also changes the object of the review. Reading a three-thousand-line dump that no one has seen exceeds anyone's attention, whereas reading a two-page specification with clear criteria fits in one sitting. Instead of reviewing mountains of code at once, the developer validates focused changes that solve specific pieces, because the specification has already said what needs building and the task has already said in what order, as the [Spec Kit announcement](https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/). Reviewing intentions is cheaper than reviewing diffs, and correcting a sentence costs less than rewriting a module.

## Concrete trials

Dimension

Vibe coding

Spec-Driven Development

Speed of the first prototype

Minutes or hours from a sentence

Hours or days with a prior specification

Code quality

Unpredictable and uneven across sessions

Bounded by contracts and verifiable

Security

OWASP Top 10 flaws in 45% according to Veracode

Tests and contracts derived from the specification

Maintenance

Opaque code that no one remembers designing

The specification serves as living documentation

Teamwork

Individual, each person negotiates with their own chat

Parallel tasks on a shared context

Context for the AI

Ephemeral, lost between messages

Persistent, versioned and auditable

There is a third, less visible effect and perhaps the most decisive one for large teams. When requirements use structured formats such as EARS, they stop being decorative prose and become computable material. Kiro analyzes them to hunt down ambiguities and clashes between requirements, and since its general release it generates correctness properties that feed tests able to try hundreds of values where a classic test only touches a few, as the technical session at [re:Invent 2025](https://dev.to/aws/dev-track-spotlight-spec-driven-development-with-kiro-dev314-45e8). With precise contracts, the model's room to invent decisions already made disappears.

It is worth noting that these figures describe specific trials, not universal verdicts. The 45% comes from tasks designed to tempt the model and the 19% measures experts in enormous repositories, but both point in the same direction.

**You may be interested in: [AI Act: how artificial intelligence affects startups in Europe](https://observatorioblockchain.com/en/ai/ai-act-startups-europeas-inteligencia-artificial/)**

## What does a developer who already uses AI every day gain?

Anyone who programs daily with Copilot, Cursor or Claude Code will notice the change where it hurts most: rework. The first sessions with a specification feel slower because they force you to think for half an hour before generating anything, and Thoughtworks said so bluntly in its November 2025 Radar, placing the method in its assess ring with warnings about its complexity, as [Thoughtworks](https://www.thoughtworks.com/en-us/radar/techniques/spec-driven-development). But that half hour pays off when the agent stops proposing the wrong library and when a colleague understands in an afternoon what used to take a week of reading.

The savings also show up in collaboration between people. With a shared specification, two developers can ask two different agents for compatible pieces of the same system, because both draw on the same data contract and the same error and logging rules. Without it, each person negotiates on their own with their assistant and the repository ends up with several ways of authenticating and several definitions of done. David Yanacek, principal engineer for agentic AI at AWS, put it clearly in remarks reported by [InfoWorld](https://www.infoworld.com/article/4166817/vibe-coding-or-spec-driven-development-how-to-choose.html). Spending time describing what is being built and what well done means allows you to go back and check that the agent did what was asked.

Many teams also apply a hybrid model without giving it a name, where exploration and delivery follow different rules. Ayaz Ahmed Khan, director of engineering at Cloudways, summed it up in the same InfoWorld piece. Use vibe coding to explore and prototype, and specification-guided AI development to harden and ship.

## Reviewing and testing remain mandatory

The question most often repeated in spaces like X has an affirmative answer. **Yes, you have to review and test everything generated with AI, even when using SDD**. The specification is not a spell that makes the model correct, but a contract that lets you catch its mistakes. The human validates the specification, plan and tasks before letting the agent execute in supervised mode.

The important nuance is that the tests are born from the specification and not from the code. A testing agent derives cases from the acceptance criteria, so that a test that passes without covering any clause of the contract reveals a hole in the net and not a pass.

To this are added the classic practices that AI does not retire, such as static analysis in the pipeline, review of dependencies and versions chosen by the agent, and attention to log injection and cross-site scripting, where Veracode measured failure rates above 85%. Simon Willison drew the line with a phrase worth framing. If a model wrote every line, but you reviewed it, tested it and understood it, that is using the model as a writing assistant, and only when you accept programs by feel without understanding them, as reported by [Ars Technica](https://arstechnica.com/ai/2025/03/is-vibe-coding-with-ai-gnarly-or-reckless-maybe-some-of-both/).

The specification can also fail if it fossilizes wrong assumptions. That is why the process always requires living documents that evolve with what is learned and frequent team checks, not contracts carved in stone.

## A practice in expansion

The ecosystem grew at a pace unusual for a practice with such a young name. Spec Kit launched as an open source experiment under the MIT license and by September 2026 had accumulated more than 100,000 stars, with more than 200 contributors, around thirty integrations and more than a hundred community extensions, according to its [documentation](https://github.github.com/spec-kit/). The tool itself is developed by eating its own dog food, with relevant changes tested through its specification commands, which in jargon is known as dogfooding and here works as public quality control.

Kiro represents the integrated bet. It was born in a small Amazon team with its own product direction, and its flow of requirements, design and tasks comes built into the IDE instead of being added as an external template. Its strengths are steering documents, hooks that automate routines and integration with the Model Context Protocol, as the workshop at [re:Invent 2025](https://dev.to/aws/dev-track-spotlight-spec-driven-development-with-kiro-dev314-45e8). Its internal cases speak of features shipped in days, figures from the company itself that each team will have to verify.

Around those two poles orbits a constellation with nuances of its own. Tessl defends the most radical stance, with the specification as the artifact that is maintained instead of the code, although in September 2025 it was still in private beta, according to the [Thoughtworks Radar](https://www.thoughtworks.com/en-us/radar/techniques/spec-driven-development). As a practical rule, the more layers a change touches, the more specification it deserves.

## Specify first and let the code obey

The debate no longer pits AI enthusiasts against skeptics, at this point in late September 2026, but rather two ways of using it with different ambition. Vibe coding keeps its territory in exploration, weekend prototypes and proofs of concept that no one will maintain, where its speed is unbeatable. Anything that must survive the third month, pass an audit or safeguard sensitive data calls for the disciplined path, with written contracts and tests born from the document.

Anyone starting today has a simple itinerary to try. Choose a small but real feature spanning several layers, write its specification with verifiable criteria, plan with explicit constraints and let the agent execute task by task with reviewable steps, measuring time, defects and review effort against the previous method. If the feature survives the quarter without turning into debt, the recipe worked and deserves to be repeated at a larger scale.
