Spec-driven development: what comes after vibe coding
Read in : Français

Contents
- What exactly is spec-driven development?
- Why it's being talked about now
- The 4 phases of spec-driven development
- Spec-driven development tools
- Spec Kit (GitHub)
- Kiro
- Tessl
- The three levels of spec-driven development
- The limits to know before you start
- When should you switch to spec-driven development?
- A copy-ready template to start without any tool
- Frequently asked questions
- Frequently asked questions
- Sources
Spec-driven development means writing down what you want before asking for code, then having the AI agent work from that document instead of from a string of improvised prompts. There are four phases: specify, plan, break into tasks, implement. It is the natural next step once a vibe-coded project outgrows the prototype stage and the AI starts breaking things that used to work.
What exactly is spec-driven development?
Spec-driven development (SDD) is a method where the specification becomes the reference document the AI agent follows to write code. Instead of saying "add a booking system," you first have a document drafted, reviewed and corrected that describes who books what, when, under which rules and with which edge cases.
GitHub, which released the open-source Spec Kit toolkit in September 2025, sums it up in one line: "Specs become the shared source of truth."
The difference from vibe coding fits in a table:
| Vibe coding | Spec-driven development | |
|---|---|---|
| Starting point | A prompt | A written, approved spec |
| What you review | The result on screen | The spec, the plan, then focused changes |
| Project memory | The chat history | Files in the project |
| Size of changes | Often huge and scattered | One task at a time |
| Best for | Prototypes, idea tests, weekend projects | Lasting features, growing projects |
If you're new to the topic, start with our complete guide to vibe coding: SDD only makes sense once you've hit the limits of coding by feel.
Why it's being talked about now
Vibe coding works well for the first few hours. Then three problems show up, and they are well documented.
- The AI forgets. Each session starts almost from scratch. Decisions made three days ago ("prices are always stored in cents") aren't written down anywhere.
- Changes get huge. A vague prompt produces an edit across fifteen files that nobody can review.
- The code goes unchecked. Veracode's 2025 report found a security flaw in 45% of coding tasks generated by more than 100 models. The bigger the change, the less likely you are to spot it.
SDD addresses all three: the spec acts as memory, breaking work into tasks shrinks each change, and every task can be checked on its own.
The 4 phases of spec-driven development
Tools differ, but the flow is the same everywhere. Here is the one GitHub describes for Spec Kit.
- Specify. You describe what you're building and why: the users, their problems, what success looks like. No tech yet. The agent drafts a detailed spec that you correct.
- Plan. You give the technical direction: stack, architecture, constraints. The agent produces a technical plan. GitHub even suggests asking for several variations to compare.
- Break into tasks. The agent turns the spec and plan into small tasks, each one doable and testable on its own.
- Implement. The agent works through the tasks one by one. You review focused changes instead of a giant code dump.
You already have the method for phase 1: it's writing the PRD before the prompt, made more formal.
Spec-driven development tools
Three names come up in every serious analysis, including the one by Birgitta Böckeler (Thoughtworks) published on Martin Fowler's site in October 2025.
Spec Kit (GitHub)
Spec Kit is an open-source toolkit that adds commands to the coding agent you already use. At launch, GitHub announced support for GitHub Copilot, Claude Code and Gemini CLI. The commands map to the phases: one for the spec, one for the plan, one for the tasks, one for implementation. The repo also adds a "constitution": the project's non-negotiable principles (mandatory tests, allowed libraries and so on).
The exact command names have changed since the announcement, so check the repository README for your version.
Kiro
Kiro is an agentic IDE introduced in July 2025, built on Code OSS (the base of VS Code) and tied to AWS: its FAQ mentions sign-in with AWS Builder ID and enterprise billing through AWS. Every spec produces three files: requirements.md for requirements, design.md for architecture and tasks.md for tasks. Acceptance criteria use EARS notation (Easy Approach to Requirements Syntax), a structured format along the lines of "when [event], the system shall [behavior]." Kiro also adds "hooks," automations that run when you save or create a file.
Tessl
Tessl, still in private beta when Böckeler reviewed it, is described as the most ambitious of the three: it aims for a spec maintained over time and explores the idea of a spec being the only file humans edit.
| Spec Kit | Kiro | No tool | |
|---|---|---|---|
| Form | Commands added to your agent | Full IDE | Markdown files and prompts |
| Agent | Yours (Copilot, Claude Code…) | Kiro's own | Any |
| Files produced | Spec, plan, tasks, constitution | requirements.md, design.md, tasks.md | Whatever you define |
| Best if | You already have an agent and want structure | You want everything in one tool | You want to try the method first |
The three levels of spec-driven development
Böckeler distinguishes three levels, and the distinction clears up a lot of confusion.
- Spec-first: the spec is written before coding a task, then possibly discarded. Most tools do this.
- Spec-anchored: the spec is kept and updated as the feature evolves.
- Spec-as-source: the spec is the only file humans edit; the code is generated from it.
For a vibe coder, level 2 pays off best: a living spec stored in the project that the agent rereads every session. That's also where context files like CLAUDE.md and AGENTS.md take over.
The limits to know before you start
SDD isn't magic, and the published criticism is specific.
- Too heavy for small tasks. Böckeler found the Kiro and Spec Kit workflows overkill for a small bug or a mid-sized feature.
- Lots of Markdown to review. Spec Kit produced many repetitive, verbose files that were more tedious to review than the code itself.
- A false sense of control. Agents sometimes ignore instructions in the spec, or over-apply them.
- A fuzzy term. Some people call a detailed prompt a "spec."
When should you switch to spec-driven development?
Here is a simple decision tree.
- If you're testing an idea you might throw away next week, then stick with pure vibe coding.
- If the feature touches payments, accounts or user data, then write a spec, even a short one.
- If the agent keeps breaking things that worked, then the project needs written memory: a spec and a context file.
- If the task fits in one sentence ("change the button color"), then skip the spec; a prompt is enough.
- If you work with other people, then the spec becomes the document you discuss before coding.
A copy-ready template to start without any tool
You can apply the method with Claude Code, Cursor or Codex without installing anything. Create a specs/ folder and paste this prompt:
We are going to work spec-driven. Do not write any code yet.
Step 1: write specs/booking/spec.md with:
- the problem and the users involved
- user journeys, step by step
- business rules (e.g. no bookings in the past)
- acceptance criteria in the form "When [event], the system shall [behavior]"
- edge cases and what is out of scope
Ask me the questions you need first, then wait for my approval.
After approval: write specs/booking/plan.md (technical choices, tables, files touched),
then specs/booking/tasks.md (numbered tasks, each testable on its own).
Only then implement task 1 and stop so I can check it.
Keep these files in the project and in Git: they are what stop the next session from reinventing everything. To pick the agent that follows this kind of plan best, compare Cursor, Claude Code and Codex, and if you're starting with one of them, read our beginner's guide to Claude Code.
Frequently asked questions
Frequently asked questions
What's the difference between spec-driven development and vibe coding?
Vibe coding starts from a prompt and judges the result on screen without reading the code. Spec-driven development starts from a written, approved specification that the agent turns into a plan and then into small, checkable tasks. The first is ideal for fast prototyping; the second for building features that need to last and stay maintainable as the project grows.
Do I need a special tool for spec-driven development?
No. Spec Kit and Kiro support the method, but you can apply it with any coding agent: a folder of Markdown files (spec, plan, tasks) and a prompt that forbids coding before approval are enough. Start without a tool to see whether the method suits you, then adopt one if you want a stricter framework.
Is spec-driven development suitable for beginners?
Yes, and it's often easier than pure vibe coding: reviewing a spec in plain English takes fewer skills than reviewing code. The spec forces you to decide the rules before the AI makes them up. The catch is that you have to accept spending time writing and reviewing before you see any result.
What is EARS notation?
EARS (Easy Approach to Requirements Syntax) is a structured way of writing requirements, used by Kiro for acceptance criteria. It follows templates such as "When [event], the system shall [behavior]." The format cuts ambiguity and makes requirements easier to check, both for you and for the agent.
Does spec-driven development replace testing?
No. The spec says what the code should do; tests check that it actually does it. The acceptance criteria in a good spec translate easily into tests. Ask the agent to write one test per criterion, and always check critical user journeys by hand.
Sources
- Spec-driven development with AI: Get started with a new open source toolkit — GitHub Blog
- github/spec-kit — GitHub
- Introducing Kiro — Kiro
- Specs — Kiro Docs
- FAQ — Kiro
- Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl — Birgitta Böckeler, martinfowler.com
- AI-Generated Code Poses Major Security Risks in Nearly Half of All Development Tasks — Veracode


