The methodology

What is Intent-Driven Development?

Intent-Driven Development (IDD) is a software engineering methodology that treats human intent as the primary artefact of delivery. People specify what should be built, why it should exist and within what boundaries; autonomous systems carry out the implementation; and the organisation measures and governs how faithfully that implementation honours the original intent.

The shift that IDD responds to

For most of the history of software, the constraint on delivery was technical capability: the languages a team knew, the frameworks available, the hardware it could afford and the time it took to write and test code. Agentic AI has changed that. Systems can now write code, generate tests, scaffold architectures and deploy services at a pace that would have seemed absurd only a few years ago, and in doing so they have exposed a constraint that was always present but rarely decisive, which is the quality of human intent.

When building was slow, unclear requirements were painful but survivable, because the feedback loop ran at human pace and teams could correct course. When building becomes close to instantaneous, unclear intent becomes far more expensive. An agent given a vague specification builds exactly what it was told, quickly, confidently and incorrectly. IDD exists to move the discipline of software development from mastering implementation to mastering intent.

The boundary between intent and execution

One useful way to read the history of computing is as a long process of moving the boundary between human intent and machine execution. High-level languages let people describe logic rather than machine operations. Frameworks absorbed infrastructure and common patterns. Cloud platforms automated provisioning, DevOps automated the pipeline, and AI now automates implementation itself. Each step moved people further from execution and closer to intent.

There is a natural limit to that movement. Machines can execute, optimise and automate, but deciding what should exist, which trade-offs are acceptable and which outcomes matter remains human work. As execution is automated, clarity of intent becomes the most important professional skill in delivery, and IDD is a methodology for working well once the boundary reaches the people doing the work. The Autonomy Boundary describes how organisations manage that line deliberately.

From five questions to six elements

IDD began with five questions that a team answers before any implementation starts: what is the intent, what does success look like, how will we prove it works, what constraints must we respect, and what are the ethical implications. As the integration with Domain-Driven Design made clear that domain context needed explicit treatment of its own, those questions became the six elements of an Intent Specification:

  1. Intent: the why and the what.
  2. Domain Context: the world the system operates in.
  3. Success Criteria: what done means.
  4. Validation: the proof that it works.
  5. Constraints: the boundaries it must respect.
  6. Ethical Considerations: whether it should be built at all.

Thinking, artefacts and systems

IDD operates on three connected levels. The first is a way of thinking, the discipline of clarifying intent before acting on it. The second is a set of artefacts, the structured Intent Specifications that capture that thinking in a form autonomous systems can execute against. The third is a set of systems: the governance, measurement and organisational models that allow intent to scale beyond a single team. Most methodologies concentrate on one of these levels, and much of the value of IDD comes from connecting all three.

The framework at a glance

The framework is organised around four capabilities, each supported by a small set of precisely defined concepts.

Specify intent
The Intent Specification captures intent in six elements, and Intent Shaping turns human goals into intent that is executable, measurable and governable.
Govern execution
Risk Dials set how much autonomy each step of a workflow is granted, Human Gates mark the checkpoints where people must decide, and the Autonomy Boundary separates what can be delegated from what stays with people.
Measure alignment
Intent Fidelity measures how closely implementations match intent, and the Maturity Model uses that evidence to gate how far autonomy expands.
Scale across the organisation
The Intent Hierarchy lets shared intent be defined once and inherited, and Intent Promotion moves proven patterns upward so the organisation learns from its own delivery.

Underneath all four sits the separation of the Human Layer and the AI Layer, which is why the framework survives rapid change in AI models and tools.

What IDD is not

It is tempting to read IDD as a sophisticated form of prompt engineering, but the two operate at different levels. Prompt engineering is a technique for interacting with a particular model at a particular moment, and its techniques have aged quickly as models have changed. IDD is a methodology for human thinking, closer in spirit to the way Test-Driven Development taught developers to think in tests before writing code, and it applies whether the implementation partner is a person, a single agent or an orchestrated system of agents.

Nor does IDD replace the disciplines that came before it. User-Centred Design discovers user needs, Domain-Driven Design models the business domain, Behaviour-Driven Development expresses expectations in stakeholder language and Test-Driven Development validates through tests. IDD reframes them around intent as the primary artefact and connects them into a single flow, so that each continues to contribute when much of the implementation is no longer done by people.

Finally, IDD is not tied to a tool, a vendor or a model. Specifications describe what to build and why, not how an AI system should organise itself internally, which keeps them stable while the tools that execute them change. For a detailed comparison with spec-driven development, see IDD and spec-driven development.

What changes when teams adopt it

When teams adopt intent-first thinking, iteration cycles shorten because success criteria are defined before implementation rather than discovered afterwards. Collaboration improves because intent is expressed in human language that product, design, engineering, security and operations can all read. Governance becomes evidence-based rather than intuitive, and the skills involved remain valuable as AI improves, because defining good intent becomes the differentiating human contribution. The responsibilities of individual roles change accordingly, which is explored in The New Practitioner and Designing Intent at Scale.

Where IDD came from

IDD was developed in public across fourteen articles published between January and March 2026, each responding to questions and challenges raised by the one before. In April 2026 the articles were reorganised, de-duplicated and expanded into a single framework, published as a free ebook whose current version is 0.2. It is a living methodology, and changes are recorded in the changelog.

Frequently asked questions

What problem does Intent-Driven Development solve?It addresses the gap that opens when AI can implement far faster than people can say clearly what they want. Without explicit intent, agents produce confident but misaligned work at speed, and IDD provides the specification, governance and measurement needed to keep that work aligned.
Is IDD only for software engineers?No. Engineers and architects tend to start with the Intent Specification, product and delivery leaders with governance and measurement, and senior leaders with the Maturity Model and Intent Hierarchy. Because intent is written in human language, non-technical leaders can take part directly.
How does IDD relate to TDD, BDD and DDD?It builds on them rather than replacing them. Domain-Driven Design supplies the domain context, Behaviour-Driven Development supplies stakeholder-readable scenarios, and the test-first thinking of Test-Driven Development moves into the specification itself, with IDD acting as the discipline that ties the flow together.
What does "Govern Intent. Delegate Execution." mean?It is the core principle of the methodology. People keep ownership of what should be built, the boundaries it must respect and the accountability for the result, while the work of implementation can be handed to autonomous systems under explicit, measured controls.