Why Intent-Driven Development matters now
Generative AI didn't make development easier. It moved the hard part. Implementation got cheap, and the old practices — vibe coding, spec docs, requirements meetings — were not built for that world.
AI changed the cost equation
For decades, writing code was the costly step. Specifications, requirements, and design docs were inputs that justified the cost of typing.
That is no longer true. Cursor, Claude Code, and autonomous agents produce working code in minutes. The bottleneck moved upstream: deciding what to build, deciding why the trade-off you made yesterday should still hold today, verifying that what shipped reflects what was intended.
The cost of implementation went down. The cost of judgement and verification did not. IDD is a response to that mismatch.
Three pains we see in AI-assisted teams
Drift
Run an autonomous agent for an hour and it solves the problem in front of it. Run it for a week and it solves a different problem. Without an anchored intent, the agent has nothing to drift from.
Re-explanation tax
Every prompt re-explains what you decided yesterday. Intent — 'we use server authority because we don't trust client input' — is repeated in every system prompt, every code review, every conversation with a new contractor.
Review fatigue
When a human reviews a PR from an agent, they compare the code against their own taste, because there is nothing else. After ten PRs in a week, taste degrades. The reviewer either rubber-stamps or starts blocking on style.
What "intent" needs to be, to fix this
- Structured. Hierarchical or relational, so a reader can navigate it. Flat lists become noise.
- Reusable. A new feature, a new agent, a new contractor — they all draw from the same intent.
- Human-readable. Curated by humans, not generated. Plain language, not just YAML.
- Machine-readable. Consumable as context by AI agents. Plain language is fine; chaos is not.
Built like that, intent stops being a one-time spec document and starts feeding the work itself. Each GitHub issue inherits the relevant slice — architecture, contracts, UI patterns — and writing a clear issue becomes the highest-leverage skill in modern AI-assisted coding. Implementation is straightforward because the context is already there; review is fast because the comparison point is intent, not the reviewer's taste.
And intent doesn't have to be perfect on day one. Intent-System runs a continuous Clarification loop: AI reviews the accumulated intent, surfaces "what about this?" questions in bulk and proposes recommendations; humans accept the recommendation where they have no strong opinion, and write their own answer where they do. Intent gets richer with every cycle, without an upfront spec marathon.
When IDD is overkill
If you are writing a one-off script, doing exploratory data analysis where the intent is the code, solo-prototyping for a single weekend, or building a tool that has no reviewers other than you — IDD is overhead with no payoff. Every page on this site says so.
IDD pays off when multiple people (or agents) touch the same codebase, the lifecycle of the system is longer than memory, and you want a record of why a trade-off was made — not just what the code does.