Spec driven development is an expression of recent usage: it refers to a way of working with a coding assistant in which you first write and review a text describing what needs to be built, then a technical plan and a list of tasks, before letting the assistant write the code.
The approach unfolds in steps: intent, specification, technical plan, breakdown into tasks, implementation, verification. Each delivers a text or code, stored in the repository, which a person reviews before moving on to the next. This breakdown is our reading of two public toolsets, consulted on 12 November 2026. The outlines of the term are still shifting; no tool is recommended here and no gain is promised.
A recent expression, carried by toolsets that differ
Two original sources give an idea of what the term covers.
Spec Kit, published by GitHub under the MIT licence (github.com/github/spec-kit), presents itself as an open source toolkit that provides coding agents with “structured processes, reusable templates, and documented outcomes” (in its own words). Its minimal path chains commands together: a “constitution” written once per project, which sets the principles to be respected, then, for each feature, specify, plan, tasks, implement and converge. Its methodology document places code at the service of the specification, a position specific to its authors.
Kiro (kiro.dev), whose website bears the Amazon Web Services name, calls specs structured artefacts that formalise the development of a feature or the fixing of a bug. Each spec rests on three files: requirements.md (user stories and acceptance criteria; bugfix.md for a bug), design.md (architecture, sequence diagrams, error handling, testing strategy) and tasks.md (discrete tasks, tracked one by one). Its documentation offers two variants, depending on whether you start from the requirements or from the design.
The two toolsets therefore do not break down the work in the same way.
The steps of spec driven development, in order
| Step | What it delivers | What the person reviews |
|---|---|---|
| Intent | A few sentences: the expected result, for whom, what remains out of scope | That the need really is theirs, before any drafting by the assistant |
| Specification | Requirements and acceptance criteria, with no technical choice | Each requirement, the forgotten cases, the questions left open |
| Technical plan | The design choices: modules, data model, interfaces, planned tests | Compliance with the architecture framework and decisions that are costly to undo |
| Breakdown into tasks | An ordered list of tasks, with their dependencies | The order, the size of each task, the means of verifying it |
| Implementation | The code and its tests, one task after another | Each change, in code review |
| Verification | A record of the gaps between the code, the specification and the plan | The gaps, and the result of the acceptance criteria run again |
A review that leaves no trace (a question, a correction, a rejection) may indicate that the text was approved without being read.
Intent and specification belong to the business
The intent is written by hand, in a few sentences. It says what must be true once the work is finished and what must not change. It belongs to the person who makes product decisions, for example the product owner in a Scrum team. Whether the feature deserves to be built is the question of a minimum viable product, to be settled beforehand.
The assistant then drafts the specification from this intent. In Kiro, requirements follow the EARS notation (Easy Approach to Requirements Syntax), on the pattern “WHEN [condition] THE SYSTEM SHALL [expected behaviour]”. Spec Kit adds two optional commands: clarify, to remove ambiguities, and checklist, which produces a checklist of requirement quality, entrusted to the reviewer by its documentation.
A model effortlessly produces a text that appears complete: the business person therefore first reviews what is missing, such as the error case, the business rule left implicit or the volume limit.
The technical plan and the tasks commit the architecture
The plan translates the specification into design choices. In Spec Kit, the plan command receives the team’s technical choices and produces a plan with supporting documents (data model, interface contracts), checking their compliance with the project’s constitution. In Kiro, the design.md file plays this role.
An experienced developer or an architect looks in it for decisions that are costly to undo: breakdown into modules, data model, exchanges with neighbouring applications. Those that commit beyond the feature are worth recording in an architecture decision record, where the reason for a choice will be sought later.
The breakdown into tasks is reviewed for the order, the size and the means of verifying each task. Both tools identify independent tasks so that they can run in parallel; as soon as several agents work at the same time, the coordination questions in our article on AI agent orchestration arise.
Implementation and verification remain subject to review and testing
The assistant executes the tasks in the order of their dependencies. What it produces enters the repository by the same path as everything else: automated checks, then review by another person, as described in our article on code review. An assistant that executes commands and modifies files acts as an agent; its permissions are limited as explained in our article on AI agent security.
Verification compares the result with what was requested. Spec Kit provides a command, converge, which compares the code with the specification, the plan and the tasks, then adds tasks if it finds gaps. This check, carried out by an assistant, does not replace tests derived from the acceptance criteria by someone who knows their intent. Our article on automated testing helps to choose the level of each check, and our software quality and testing page recalls the limit of a test derived from the code it is supposed to check.
Neither a requirements specification, nor BDD, nor free use of an assistant
The requirements specification describes the need for an entire application and is agreed between parties, before a project is committed: our article on the application requirements specification details its content. The specification discussed here concerns one feature, lives in the repository and is reviewed at each step.
Behaviour-driven development rests on a three-way conversation (business, development, testing) that describes the expected behaviour through examples. Its scenarios can serve as acceptance criteria in a specification; the conversation itself cannot be delegated to an assistant.
Free use of an assistant goes from the request to the code with no intermediate text. It suits a change that can be checked on the spot. The rules to set before rolling out an assistant widely, with or without specifications, are those in our article on AI-assisted development. At the other end of the scale, a more structured framework distributes these steps among agents specialised by role: our article on the BMAD method presents it.
For a first trial, we suggest choosing a bounded feature, naming the reviewer of the specification, the plan and the tasks before starting, then noting what each review changed. Running such a project, from framing to go-live, falls under our custom software development page.