What is the intent gap in software development?

The intent gap is the structural distance between informal natural language requirements — how developers describe what they want — and the precise program behavior that actually gets built. Formally documented by Microsoft Research (2026), the gap exists because informal descriptions are ambiguous, underspecified, and never formalized into a persistent artifact before building begins. AI models infer the intent and build against that inference, not against the actual intent.

Why does AI code drift from what you meant?

AI code drift happens because the model builds against an inference of your intent, not a formalization of it. When you describe a project in a chat window, the model infers what you mean and proceeds. The inference is usually close — but close is not right. Each session starts from a slightly different inference. Over time, the drift compounds. The root cause is that intent was never written down in a form that persists, traces, and governs.

How does Ada close the intent gap?

Ada closes the intent gap by formalizing intent before building starts. It runs structured elicitation to surface blocking unknowns, then compiles through a 7-stage pipeline (CTX → INT → PER → ENT → PRO → SYN → GOV) that produces governed artifacts — CLAUDE.md, agent files, and hook files. These artifacts encode intent structurally. Claude Code builds against them rather than against an informal description.

Is the intent gap the same as prompt engineering problems?

No. The intent gap is structural, not a prompting problem. Better prompts produce better guesses — but they are still guesses made against informal input. The intent gap exists because informal requirements are never formalized into a persistent artifact before building begins. Prompt engineering addresses the quality of the guess. Closing the intent gap requires formalizing the requirements before the guess is made.

Ada → The Intent Gap

The intent gap

Why there is always distance between what you describe and what gets built — and why better prompts don't fix it.

What the intent gap is

Every time you describe a project to Claude Code, something happens before a single line of code is written: the model infers what you mean.

That inference is not your intent. It is the model's best guess at your intent, given informal, unstructured, underspecified natural language. The gap between that guess and your actual intent is the intent gap.

For small, simple projects, the gap is negligible. The guess is close enough. But as scope grows, sessions multiply, and decisions accumulate — the gap compounds. Each session, Claude Code builds from where it thinks you left off. Which isn't quite where you left off.

Microsoft Research formally documented the intent gap in March 2026, naming it the structural distance between informal natural language requirements and precise program behavior. It is not a new problem — it is the oldest problem in software requirements, now accelerated by AI.

Why it happens

Intent is informal by default

Natural language is ambiguous. "Build a dashboard" leaves open: what does it track, who uses it, what does privacy mean, what is the update frequency, where does data come from, what is out of scope. The model makes assumptions. The assumptions become code.

Intent is never formalized

The description exists in a chat window. The chat window closes. The next session starts fresh — with the model inferring the same intent again, from a slightly different starting point. Nothing was written down in a form that persists, traces, and governs.

The gap is invisible until it isn't

Small deviations from intent don't surface immediately. The code looks right. Tests pass. But the entity model is subtly wrong. The scope crept beyond what you intended. The constraint you implied was never enforced. By the time the drift is visible, rewinding is harder than starting over.

Memory tools capture drift, not intent

MEMORY.md, auto-memory, session notes — these record what happened during the session. They help Claude Code remember. But they capture the AI's observations, not your intent. If the inference was wrong from the start, memory compounds the error.

Why better prompts don't fix it

The instinct is to write a better prompt. More specific. More detailed. Clearer constraints.

This helps. A well-written prompt reduces the inference error. But it doesn't close the intent gap — because the prompt is still informal, still ephemeral, and still only present for one session.

The next session, you write it again. Or you paste it from somewhere. Either way, you're re-expressing informal intent, session by session, hoping the inference stays consistent.

The intent gap is structural. It closes when intent is formalized into a persistent, governed artifact — not when the description gets better.

Better prompts

Reduces inference error per session

Doesn't formalize or persist intent

MEMORY.md

Helps AI remember observations

Captures drift, not original intent

Auto-memory

Records what happened automatically

Still retrospective — based on inference

Ada

Formalizes intent before building starts

Not zero distance. Less.

How Ada closes it

Ada addresses the intent gap at its root: the absence of formalized intent before building begins.

Before Claude Code starts, Ada runs structured elicitation — a focused session that asks the questions specifically designed to surface what's underspecified, what's ambiguous, and what the "what it is not" answers are. These are the questions that reveal the intent gap before it becomes wrong code.

The answers are compiled through a 7-stage pipeline into governed artifacts: CLAUDE.md (read on every turn), agent files, and hook files. These encode intent structurally — not as a description, but as a constraint layer.

Claude Code builds against the artifacts. The artifacts trace back to your words. The distance between what you meant and what gets built is smaller — not zero, but less.

How Ada works →

$ git clone https://github.com/alexrozex/ada

Structured elicitation before building. Governed artifacts that persist.

Get started →