Comparison
Intent-Driven Development and spec-driven development
Spec-driven development (SDD) and Intent-Driven Development (IDD) share a conviction: when coding agents do much of the implementation, the written description of what to build becomes the most important artefact in delivery. They differ in scope. SDD is chiefly a development workflow in which a specification becomes the source of truth a coding agent works from. IDD is a methodology for the whole delivery system, adding the governance of autonomy, the measurement of alignment and an organisational structure for shared intent.
What spec-driven development does
Spec-driven development emerged as teams found that conversational, prompt-by-prompt coding with agents produced work that was quick to start and hard to sustain. Its answer is to write a durable specification before implementation and to treat that specification, rather than the chat history, as the reference point for the agent. Tools such as GitHub Spec Kit, Kiro and OpenSpec structure the work as a progression from requirements to design to a set of tasks that the agent then implements, with the specification kept alongside the code so that it can be revisited and revised.
The name "intent-driven development" is also used within this movement, usually to describe the practice of articulating intent clearly enough for coding agents to act on it without guessing, with spec-driven development treated as one way of putting that into practice. That usage and the methodology described on this site start from the same observation and then travel in different directions, which is the subject of this page.
Where the two overlap
The common ground is substantial, and it is worth stating plainly before describing the differences. Both approaches insist that intent is made explicit before code is generated, rather than inferred from the output afterwards. Both treat tests and acceptance criteria as part of the specification instead of a downstream activity. Both aim for artefacts that outlast a single session, a single model and a single developer, and both are a deliberate response to the speed at which agents can now produce plausible but misaligned work.
Where IDD goes further
The differences follow from the question each approach is trying to answer. SDD asks how a developer can get reliable output from a coding agent. IDD asks how an organisation can delegate execution to autonomous systems at scale while remaining accountable for what gets built. Answering the second question requires several things the first does not.
| Concern | Spec-driven development, typical focus | Intent-Driven Development |
|---|---|---|
| Central question | How do we get reliable output from a coding agent? | How do we delegate execution at scale and remain accountable? |
| Unit of work | A feature or change, described in a specification | An Intent Specification that inherits shared intent from domain and organisation levels |
| Governing autonomy | Left to the team's own review practice | Risk Dials set Red, Amber or Green control at each step, and Human Gates fix where people must decide |
| Measuring alignment | Verification against the specification's tasks and tests | Intent Fidelity across completeness, correctness, alignment and consistency, applied to human and AI work alike |
| Ethics | Not usually a defined part of the specification | Ethical Considerations is one of the six elements, and ethical boundaries are never delegated |
| Scaling | Specifications per project or repository | The Intent Hierarchy and Intent Promotion share and refine intent across the organisation |
| Adoption path | Adopt the workflow and tooling | The Maturity Model gates each expansion of autonomy on measured alignment |
| Primary audience | Developers working with coding agents | Engineers, architects, product and delivery leaders, and senior leadership |
Governance is the most consequential of these differences. In most organisations the hard question about AI in delivery is not whether an agent can write the code but who decides how far to trust it, on what evidence, and what happens when it is wrong. Risk Dials answer the first part by making the level of autonomy an explicit, reversible decision taken by the organisation rather than by a vendor or a tool. Intent Fidelity answers the second by turning trust into a measured quantity, with thresholds that tell a team when a dial can safely move. The Autonomy Boundary answers the third by identifying the decisions, such as strategic intent, ethical boundaries and final production approval, that stay with people regardless of how good the measurements become.
Scale is the second difference. A team writing its first specifications quickly finds the same regulatory requirements, security baselines and architectural patterns repeated in every one. The Intent Hierarchy lets that shared intent be defined once at Organisation or Domain level and inherited by projects, while Intent Promotion moves patterns that prove themselves in delivery back up the hierarchy. The result is an organisation that learns from its own projects, rather than a collection of well-specified repositories that each rediscover the same constraints.
Using them together
The two approaches are complementary rather than competing. IDD separates delivery into a Human Layer, where intent, governance and accountability live, and an AI Layer, where implementation happens. Spec-driven tools sit naturally in the AI Layer, or at the interface between the two: they take a specification and turn it into designs, tasks and code. An Intent Specification makes a strong input to that process, because it already contains the domain context, success criteria, validation, constraints and ethical considerations that a coding agent needs.
A team already using Spec Kit, Kiro or OpenSpec does not need to replace its tooling to adopt IDD. What IDD adds is the layer above the tools: deciding where each step sits on the Risk Dials, measuring the fidelity of what the tools produce, and sharing intent across teams so that each specification inherits what the organisation already knows. Because Intent Specifications are tool-agnostic, the tools can be swapped as the market moves without rewriting the intent they work from.