Intent-Driven Development: 5 IDD Architect Decisions for 2026

Why a spec alone doesn’t close the coordination gap between agents, and five architect decisions that do.

“If you want to build a ship, don’t drum up people to collect wood and don’t assign tasks. Instead, teach them to yearn for the vast and endless sea.” — Antoine de Saint-Exupéry, writer (paraphrase from Citadelle, 1948)

You’ve been writing PRDs and ADRs for the last fifteen years. They were context documents — a supplement to code, which was the real source of truth. You were writing intent, but nobody called it that.

Today, in 2026, the economics of code production have inverted. A US team, KodeNerds, built a HIPAA-compliant healthcare platform with a three-person crew — 55% of the time went to writing intent, and only 20% to coding. That wasn’t an exception. That was the map of the new SDLC.

The architect didn’t disappear. The role flipped from the inside — from function writer to framework writer. Over the next nine minutes, you’ll see how intent became the primary engineering artifact, why Sartori 2026 proved that even a full spec doesn’t close the coordination gap, which four intent languages are competing for your stack, and what five concrete decisions every architect needs ready by Monday.

Quick Win — Core Insight

If you’re leaving this article after three minutes, take this with you:

The architect’s role in 2026 has shifted up by one level of abstraction. Just as C abstracts Assembly, and TypeScript abstracts JavaScript, intent now abstracts all code. An LLM agent can generate a class faster than a human reads a PR description — so coding speed isn’t the bottleneck. Clarity of intent is.

Five things that changed for the architect:

• Your primary artifact is the intent document, not the architecture diagram. PRDs and ADRs were always intent — just wearing old clothes.
• Agents are stateless. Every session starts from scratch. The intent document is the only memory between sessions. Without it, your agent team is amnesia on repeat.
• Four intent languages are competing for your stack: living spec, structured constitution, JSON/YAML schemas, and executable coverage matrices. The choice isn’t neutral — it determines how your agents work.
• A spec alone isn’t enough. Sartori 2026 proved that a 25–39-point coordination gap persists even with a perfect L0 spec.
• The architect no longer writes functions. The architect writes frameworks: boundaries, acceptance criteria, governance hooks, and drift control.

The full mechanics of this inversion — and the five decisions you need ready by Monday — are below.

SDLC Inversion — What Broke After Code Commoditization

The economics of the SDLC inverted between 2024 and 2026. What used to consume 50% of project time (coding) now takes 20%. What used to take 15% (clarity, intent) now takes 55%. This isn’t a percentage shift — it’s an inversion of the entire cost hierarchy.

The clearest empirical evidence is the healthcare HIPAA platform built by KodeNerds in 2025. Team composition: Product Engineer, Technical Architect, and AI Ops Lead — three people instead of ten, at 30% of baseline cost. KodeNerds doesn’t give a precise delivery time, stating only “in less time than a full traditional team would require.” An independent case tells a similar story: Keyhole Software compressed an insurance platform from a projected 18–24 months down to roughly 5 months. Time-to-implementation dropped threefold, and time-to-clarity tripled.

SDLC inversion: time that coding used to consume is now consumed by writing intent. Source: KodeNerds 2025 healthcare platform analysis.

There’s an interpretive trap worth flagging here. Academic measurements from 2023 (n=95 professional developers recruited via Upwork, isolated JavaScript greenfield tasks) show double-digit percentage gains from AI. A parallel study from 2025 (n=16 experienced open-source developers — averaging five years of contributions to mature projects, ~22,000 GitHub stars, 1M+ LOC, 246 tasks: bug fixes, refactorings, and feature enhancements) shows -19% efficiency. These aren’t contradictory results — they’re measurements under different conditions. AI accelerates greenfield and slows down brownfield. Every number comes with a different n, a different population, and a different scope. There’s no single AI productivity figure — there are maps of where it applies.

For the architect in practice: a classic ten-person Agile team loses twenty-one hours a week on standups alone. IDD replaces ceremonies with intent reviews — shorter, involving fewer people, and documented. The architect loses 30–50% of their time to spec writing, but gains a complete rewrite of what the project’s objectives are. The price: learning to write intent docs as a core skill, not an afterthought.

Once time is dedicated to intent — what exactly does that mean? Because intent in 2026 isn’t what you were writing in 2015 specs. It’s an agent’s memory, and agents are stateless. Those two facts connect in a non-obvious way.

Intent as Agent Memory

LLM agents are fundamentally stateless. Every invocation starts with a fresh context. Without an intent document, the agent has to guess what to do on every call — and the result is chaos. Picture a team where every employee wakes up with amnesia each morning. What you wrote yesterday is the only thing they remember.

In practice, this plays out exactly as one senior Java developer described it: “Initially great, then destroying functionality while trying to fix.” Without a framework, the agent loses context, hallucinates API contracts, and breaks implicit invariants. Three weeks later, the team discards the AI-generated code and manually rewrites half of what the agent produced — because that’s cheaper than fixing it.

IDD architecture: the intent document is the only persistent state. Coordinator delegates, Verifier checks compliance, Implementor writes code. Resetting agents doesn’t break the system — because truth lives in the intent doc.

The architecture looks different once you accept statelessness as a constraint rather than a problem to work around. In a mature setup, the Coordinator Agent — an agent-orchestrator that decomposes intent into tasks — reads the intent document, breaks it into assignments, and delegates to specialized agents. The Implementor writes code. The Verifier — independent of the Implementor — checks that the generated code matches the intent doc before merging and blocks PRs that violate intent. The entire team operates on a single shared artifact.

The intent document is the only persistent state of the system. The implication is non-obvious: when the intent document is the only memory, everything else becomes derived output. Code, tests, and infra can all be regenerated from intent, but not the other way around. That changes the hierarchy of what the architect must guard. A practical analogy: an API contract between human teams is exactly what an intent document is between agent teams — the same mental model, different recipients.

Four Intent Languages — Where to Write and For Whom

The term “intent” means something different in Augment Intent, something else in GitHub Spec Kit, and something else again in schema formats like mox_eda. In 2026, it’s a Tower of Babel word. You need to know which dialect your stack speaks — because the choice isn’t stylistic; it’s architectural. It determines the rigor of the contract and resilience against drift.

Four modalities are competing for your stack.

• First: a living spec — bidirectional sync between the spec and the code. The Coordinator updates the spec when the implementation changes an API. Ideal for complex multi-service brownfield codebases where static specs would drift anyway. Trade-off: vendor lock-in and licensing cost.
• Second: a structured Markdown constitution — a rigid set of Markdown files defining goals, tech stack, and roadmap. Representative tool: GitHub Spec Kit (MIT, agent-agnostic, integrates with 30+ agents). Ideal for open-source cross-agent work. Trade-off: maintenance burden — when the project changes, you update the constitution manually.
• Third: structured declarative schemas — JSON and YAML as a contract. The strictest option. The open-source project mox_eda provides the cleanest example: an AsyncAPI specification (the event-driven API analog of OpenAPI) describing 122 event types mapped across 14 bounded domains, 74 tasks, and 73 acceptance criteria. Result: 82 GitHub issues, roughly 343 dev-days of work, and zero ambiguity. Ideal for deterministic enterprises. Trade-off: enormous upfront cost — in smaller projects, it kills velocity.
• Fourth: executable coverage matrices — intent as an enumerable specification surface, a table enumerating every functionality the system supports, used as a living specification by autonomous tests. The flagship DeFi case (Kitchen Loop): 1,094 merged PRs at an average of $0.38 each, and zero regressions across 285 iterations. Ideal for self-evolving production systems, but only for very mature systems with solid test coverage.

Four intent languages — from the most dynamic (living spec) to the most rigid (coverage matrices). The choice determines your agent team’s workflow.

The decision tree for the architect is simpler than it looks. Brownfield enterprises with a team of 5+ → Augment Intent or a living spec equivalent. Open-source with a cross-agent requirement → GitHub Spec Kit. Deterministic enterprise with compliance pressure (HIPAA, EU AI Act) → JSON/YAML schemas. Autonomous evolution in critical production → coverage matrices. For most European enterprise contexts (brownfield, regulated, multi-team), the realistic candidates are the first two.

Choosing a format is less than half the decision. Because even a perfect spec doesn’t close the coordination gap. Empirical measurements from 2026 proved that, to the percentage point.

Sartori 2026 — Why Even a Perfect Spec Isn’t Enough

Camilo Chacón Sartori published a 2026 paper titled “The Specification Gap: Coordination Failure Under Partial Knowledge in Code Agents.” It’s the aha-moment of IDD — and the foundation for every decision about when to decompose tasks into a multi-agent system versus hand everything to a single agent.

Experimental setup: 51 class-generation tasks. Two agents with opposing structural biases (Agent A preferred lists, Agent B preferred dictionaries). Four specification levels — L0 is full docstrings with concrete data structures; L3 is bare signatures with no context. Research question: does a richer spec close the gap between the single-agent baseline and the multi-agent split?

The results show a monotonic degradation. Two-agent split integration accuracy drops from 58.2% with a full L0 spec to 24.6% at L3. The single-agent baseline drops from 88.6% at L0 to 55.8% at L3 — but the decline is shallower. A coordination gap of 25–39 percentage points persists across all specification detail levels. A richer spec doesn’t close that gap.

Gap decomposition: 16pp pure coordination cost plus 11pp information asymmetry.

Sartori 2026 specification gap: multi-agent split never matches single-agent baseline, regardless of specification level. Coordination cost is a separate dimension from specification quality.

Sartori describes this as a persistent structural property of the system: even when teams invest in comprehensive specifications, multi-agent architectures that split code generation across agents will incur measurable performance penalties relative to a single agent with full context. The penalty doesn’t stem from ambiguous specs — it stems from the inherent difficulty of producing structurally compatible code without shared state (paraphrased from arXiv:2603.24284).

The recovery experiment added a second layer of surprise. Error logs — Δ=0.0 points. Conflict reports between agents — Δ=0.0 points. The only thing that restores the system to an 88.9% pass rate is the full L0 specification. As the paper’s abstract puts it: the specification is simultaneously the primary coordination mechanism and a sufficient repair instrument (paraphrased from arXiv:2603.24284).

Here it’s worth reaching for a historical anchor. In 1995, Charles Simonyi at Microsoft Research proposed Intentional Programming — an attempt to build a language where intent (the goal) is the primary artifact, and code is merely its rendering. Simonyi left Microsoft Research in September 2002 to develop IP independently as Intentional Software Corporation. He himself articulated the diagnosis: “Intentional programming does not save total initial effort — it merely re-factors it. Arguably, writing transformations is harder than writing code — although this is not clearly so and the cost differential is probably a wash.” The upfront cost of defining transformations was, at the time, higher than the generation payoff — though Simonyi himself hedged that assessment. What changed in 2026: those same transformations are now written by a Coordinator Agent with an LLM, not a human. The cost differential from 2001 no longer applies. The same pattern is returning because the economics of its implementation have shifted.

The implication for the architect is stark. Decomposing a task across agents means parallelism and speed, but carries a 25–39pp penalty. Concentrating means consistency and accuracy, but involves serial execution and context window limits. There’s no free lunch in multi-agent systems. The architect in 2026 doesn’t hide behind “a better spec.” The architect decides consciously per task: cost-optimized split or correctness-optimized concentration.

Sartori showed what’s missing. The five architect decisions for Monday — what to add concretely.

Five Architect Decisions for Monday

These five decisions aren’t best practices. They’re the minimum viable constitution for an IDD architect — without them, operationalizing agents in a real production context ends in Reddit-failure mode within three weeks. Before you hand agents a keyboard, give them a constitution — in five articles.

• Decision 1: Intent format. The choice from section 3, committed in writing. For most brownfield enterprises, the default I recommend is GitHub Spec Kit — MIT, agent-agnostic, low vendor lock-in. Use a living spec (Augment Intent) when budget and tooling are already stabilized early in the organization. The decision must be written down before the first sprint — because every agent in the pipeline reads intent in the chosen format.
• Decision 2: Verifier Agent strategy. Decide whether the Verifier is a separate agent (Augment pattern, higher coordination cost) or a deterministic schema validator (cheaper, less flexible). Anchor from the Sartori section: when a task is decomposed, the Verifier MUST be independent of the Implementor. Otherwise, you absorb the full 25–39pp coordination gap with no safety net. In a single-agent setup, a deterministic validator is sufficient and cheaper.
• Decision 3: Governance hooks. Commercial endorctl ai-audit or a custom adapter that intercepts the JSON payload from the agent harness (Claude Code, Cursor), normalizes the event, streams it to a centralized backend, evaluates it against a policy set (sensitive-file patterns, MCP server allowlists), and issues a synchronous permission decision — deny or allow. MCP — Anthropic's standard protocol for MCP servers that deliver context to agents on demand — gives you the interface. An audit trail is a requirement under the EU AI Act for high-risk systems — originally from August 2026; after the May 2026 amendment, the deadline was pushed to December 2027 (Annex III) and August 2028 (Annex I). Penalties remain: up to €15 million or 3% of global turnover. Without governance hooks, a compliance audit will kill you before productivity ever does.
• Decision 4: Drift control. GitOps plus Regression Oracles (Kitchen Loop pattern). An ArgoCD pull-based sync between declared intent state and live staging. A Regression Oracle — an automated test that continuously answers “is the system at least as good as the previous iteration?” — ensures the agent doesn’t introduce silent regressions. Pause Gates — automatic pipeline stops when a complexity metric or regression score exceeds a threshold — block the pipeline on a complexity spike or accuracy slip. Without these two, a system with agents drifts within three weeks, and nobody can tell where the divergence started.
• Decision 5: Brownfield context blindness mitigation. Agent context windows (typically 200k tokens) are smaller than real codebases (1M+ LOC). Without a Context Engine MCP (a subsystem that semantically indexes the codebase and delivers relevant context to agents on demand), agents hallucinate API contracts, break implicit invariants, and snap dependencies. Benchmark anchor: the 300 Elasticsearch PR benchmark (Augment Code, 2026) showed a +71% improvement in code quality with Context Engine MCP vs standard retrieval — measured as a composite quality score covering correctness, completeness, best practices, code reuse, and documentation (Cursor + Claude Opus 4.5 configuration). For brownfield enterprises, this isn’t a nice-to-have. It’s a prerequisite — without it, the agent is like a new junior developer thrown into a project with no onboarding.

The IDD architect’s constitution in five decisions. Without all five, the pipeline is organizational amnesia.

These five decisions are mutually dependent. Decision 1 defines what the Verifier (Decision 2) checks against. Governance hooks (Decision 3) consume the same JSON payload that the Coordinator Agent generates under the intent from Decision 1. Drift control (Decision 4) audits the divergence between Decision 1 and shipped reality. Brownfield mitigation (Decision 5) feeds the Coordinator a semantically indexed context, so that Decision 1 is actually achievable in a legacy codebase. Skip any one of the five, and the rest leak.

Summary — What to Take from This Article

Five things that changed for the architect — things to bring to your next team retro:

• Your architect role in 2026 has flipped up by one level of abstraction. Just as C abstracts Assembly, intent abstracts all code. Time-to-clarity has replaced time-to-implementation as the primary constraint.
• The intent document is the only persistent state of the agent system. Everything else (code, tests, infra) is derived output. Resetting agents doesn’t break the system if the intent is well-written.
• Four intent languages are competing for your stack. The choice isn’t stylistic — it’s architectural. The decision tree above gives you a default per scenario.
• Sartori 2026 proved it: a spec alone doesn’t close the coordination gap (25–39pp). Decomposing vs. concentrating is a conscious per-task decision for the architect, not an automatic multi-agent default.
• Five decisions, minimum viable. Format, Verifier, Governance, Drift, and Brownfield. Without them, the pipeline is organizational amnesia.

Practical implications across three time horizons. On Monday, open the team retro with the five decisions from section 5 as the agenda. Next quarter, reallocate your own time — from code reviews to intent reviews. Over the next year, learn to write intent docs as a core skill, not an afterthought — that’s the skill that prices your role after 2026.

Closing

“Management is doing things right; leadership is doing the right things.” — Warren Bennis, Leaders (1985) [often misattributed to Drucker]

Bennis was right forty years before AI agents: management is doing things right, leadership is doing the right things. In 2026, that’s not a metaphor — it’s an operating model. The agent does things right at whatever speed the code allows. The architect does the right things — defines what “right” means, writes the boundaries, acceptance criteria, and escalation paths.

Industry leaders walked back the “just vibe with it” position in 2026 when production data came in. Writing frameworks instead of functions isn’t part of your job. It is your job.

On Monday, open the team retro with the five decisions from section 5 as the agenda. Let me know in the comments which of the five turned out to be the hardest to address in your context — that’s the one I learn the most from.

To those who’ve made it this far, thank you for your time.