Comprehension at AI Speed: Building a Context Store for Evolutionary Architecture

Stella Berhe, Stephan Bragner, Vikram Maran, Anand Jayaraman · rss · 2026-07-14 source ↗ Reader 🖥️

Code Was Never the Bottleneck Cognitive Debt Context Store Evolutionary Architecture & Fitness Functions Intent Debt Spec-Driven Development Test-Driven Development Verifiability (as the Quality Bar)

Because AI has decoupled writing code from understanding it, engineering organizations must run spec-anchored specification-driven development, test-driven development, and architectural fitness functions together as one verification system so that their combined artifacts form a versioned, queryable "context store" — making comprehension a lifecycle property of evolutionary architecture that both human reviewers and AI agents can draw on, rather than a pre-merge concern that AI-generated speed otherwise outruns.

practical · mixed — Argumentative core (data + framework building toward a prescription) wrapped around two narrative anchors (the Copilot/METR productivity reversal, the Amazon outage) and closed with concrete first-step actions per discipline — the piece ultimately argues for what teams should do, not merely what is true.

Structure

Part	Role
Opening data: GitHub Copilot's 2023 55.8% speedup study versus METR's 2025 RCT finding experienced developers 19% slower (with a 39-point perception gap)	evidence
The 80/20 shape of AI-assisted feature work: the first 80% feels fast, the last 20% (integration, edge cases, undocumented constraints) is where the real cost surfaces	evidence / framing
"The Context Gap at Two Altitudes": Amazon's March 2026 outage (team altitude) and Google's 2025 DORA report finding AI adoption correlates with delivery instability (leadership altitude)	evidence establishing organizational stakes
Reframing comprehension as an architectural characteristic, alongside availability, elasticity, resilience, and security, via Phillip Mortimer's QCon London 2026 talk	conceptual pivot
The Framework: spec-anchored SDD (intent layer), TDD (behavior layer), and architectural fitness functions (structural layer), each given a definition, a non-negotiable social practice, a named failure mode, and a first step	core argument body
The context store itself: four layers (structure, lineage, behavior, conformance) projecting into a machine-readable knowledge graph and a human-readable system spec, illustrated by a reviewer querying why a service rejects requests over 5MB	synthesis / payoff
Conclusion restating the stakes (Amazon and DORA reading from "the same bill") and reframing the context store as a lifecycle artifact, not a pre-merge one	conclusion

Key terms

Context store Context Store
A deterministic, versioned record of design intent, behavior, and architectural conformance, produced as a byproduct of spec-anchored SDD, TDD, and fitness functions run together, persisted in the repository and queried by both humans and AI agents across the system's whole lifecycle.
Context gap
The decoupling, unique to AI-assisted development, between code shipping at machine speed and the understanding (intent, behavior, architectural reasoning) that used to be produced automatically as a side effect of a human typing the code.
Comprehension (as an architectural characteristic)
A property of a system, on par with availability, elasticity, resilience, and security, that a team must deliberately design for and protect rather than assume — because AI has made it possible to lose.
Spec-anchored SDD
Specification-driven development where the spec is a living, machine-readable artifact authored and reviewed like code, amended whenever reality diverges from intent — as opposed to a one-time document generated to brief an agent and never revisited.
The 80/20 gap
The observation that AI dramatically accelerates the first 80% of a feature (scaffolding, compiling, generated tests, working demo) while the last 20% — integration, edge cases, undocumented constraints, institutional memory — remains slow and is where architecture actually lives.

Propositions

explicitAI-assisted development decouples writing code from building an understanding of why the code looks the way it does, because the act of writing no longer forces the learning the way it used to for a human author.conf: high
supportsThe Intent Debt · p14 — Both frame AI as separating the artifact (code) from the reasoning that produced it; this article names the general phenomenon 'the context gap' where Osmani names the specific unpaid debt 'intent debt.'
explicitestablishedAggregate productivity metrics for AI-assisted coding are unreliable and mislead the developers being measured: METR's 2025 RCT found experienced developers took 19% longer with AI tools, yet the same developers estimated afterward that AI had made them 20% faster — a 39-point perception gap.conf: high
supports ←Measuring AI's Impact on Delivery Speed · p8 — Both point to the METR 2025 RCT finding that experienced developers were measured as slower with AI while believing themselves faster.
supports ←Are You Getting Your Money's Worth from AI? · p4 — Both cite the same METR 2025 RCT finding that developers' self-assessed AI speed gains diverge sharply from measured performance.
explicitAI makes the first 80% of a feature feel dramatically faster, while the last 20% — integration, edge cases, undocumented constraints, institutional memory — is where architecture lives and is hidden by the earlier speed until it's too late to choose otherwise.conf: high
explicitcorroboratedComprehension is a newly visible architectural characteristic that must be designed for and protected, joining established characteristics like availability, elasticity, resilience, and security.conf: high
supports ←Presentation: The Future of Engineering: Mindsets That Matter When Code Isn't Enough · p5 — Greene's anecdote (coding agents make uncomprehended codebases trivially easy to create) is a concrete illustration of the claim that comprehension is a newly visible architectural characteristic that must be deliberately designed for and protected, alongside availability and resilience.
explicitdevelopedA context store — a deterministic, versioned record of intent, behavior, and architectural conformance, whose source of truth is the repository's own artifacts rather than an LLM's memory of them — is what organizations actually need to close the context gap.conf: high
extendsThe Intent Debt · p25 — Agrees specs/AGENTS.md/ADRs are the right substrate for externalized intent, and extends the claim by proposing they be unified into one versioned, queryable 'context store' fed by three integrated disciplines rather than maintained as separate artifacts.
extends ←Presentation: From Retrieval to Reasoning: Building Production-Ready Agentic AI Systems with Knowledge Graphs · p1 — Provides an independent, knowledge-graph-based instantiation of the 'context store as substrate, not retrieval optimization' idea, with an empirical (though small) token/turn efficiency finding the context-store piece asserts only conceptually.
explicitRunning spec-anchored SDD, TDD, and architectural fitness functions together, on one cadence, as a single verification system produces the context store as an emergent byproduct; none of the three disciplines is individually new, but their deliberate integration is.conf: high
extendsSam Hatoum's Post · p9 — Agrees specs serve as durable external memory for design intent, and extends the claim by pairing spec-anchored SDD with TDD and fitness functions so behavior and structural conformance are persisted alongside intent, not just intent alone.
supportsArchitecture as Code to Teach Humans and Agents About Architecture · p3 — Both treat deterministic, executable constraints (fitness functions here, architecture-as-code there) as the mechanism by which architectural intent becomes something AI agents, not only humans, can act on and be judged against.
explicitEach of the three disciplines collapses into a specific, named failure mode when its accompanying social practice is absent: specs decay into "spec-first-then-discard" documentation theater, TDD becomes a coverage-gate tax written after the fact, and fitness functions get bypassed by a synchronous review board or an overloaded single senior engineer.conf: high
supportsPodcast: Formal Methods for Every Engineer in an AI-Powered Future · p14 — Independently converges on the same failure mode: a specification left unmaintained in the repository drifts from the implementation and becomes actively misleading rather than merely stale.
explicitdevelopedBecause senior-reviewer capacity in AI-accelerated codebases is finite, architectural conformance should be pushed off the reviewer's plate and onto automated, CI-blocking fitness-function sensors, so PR review stays an interrogation of why rather than a checklist of what.conf: high
extendsAgentic Code Review · p6 — Agentic-code-review documents reviewers no longer keeping pace with AI-generated volume; this article's prescription — push structural conformance onto CI-blocking fitness functions — is offered as a direct fix to that documented capacity collapse.
extends ←Article: Agentic Fitness Functions: Extending Evolutionary Architecture Beyond Deterministic Rules · p2 — Context-store piece pushes conformance checking onto CI-blocking deterministic fitness-function sensors to free reviewer capacity; this article extends the fitness-function concept itself to add a calibrated, non-blocking judgment layer for concerns those deterministic sensors structurally cannot reach.
explicitThe context store is a lifecycle artifact rather than a pre-merge one: before deployment it briefs AI agents and grounds reviewer interrogation, and after deployment it supports debugging, architecture planning, and system-integration decisions.conf: high
implicitTreating comprehension as an engineerable, protectable architectural characteristic assumes that understanding is chiefly a systems/process problem addressable through artifacts and CI gates, rather than an individual cognitive or skill problem that procedural fixes cannot fully reach.conf: medium
implicitThe article assumes a single, sufficiently coherent organizational "design intent" exists to be captured in one spec-anchored specification, rather than multiple stakeholders holding competing, unreconciled intents that the spec-authoring process itself would need to negotiate.conf: medium

Arguments

Organizations building software with AI need a context store — a persisted, queryable record of intent, behavior, and conformance — rather than simply accepting faster raw code production as the win. strength: medium

Explicit premises:

AI decouples code writing from the understanding-building that used to happen automatically alongside it.
Two divergent studies (Copilot +55.8% in a controlled task, METR -19% in a real-codebase RCT) show that raw completion-speed measurement is unreliable and is not the thing that actually matters.
The 80/20 shape of AI-assisted work means the current pace hides architectural cost until an incident, departure, or re-platforming decision exposes it.
Amazon's outage and DORA's 2025 instability finding are both symptoms of the same underlying gap, showing up at the team altitude and the leadership altitude respectively.

Implicit premises:

Slowing down AI-generated code production is not an acceptable fix, because that speed is a real productivity win and "not the problem worth solving" — so any solution must add a parallel comprehension mechanism rather than throttle AI.
A gap that stays invisible until a production incident, key departure, or re-platforming event exposes it is nonetheless costing the organization continuously in the interim, even though nothing in the article measures that ongoing, unexposed cost directly.

Inferences:

If comprehension really is architecture's newly binding constraint, the tools evolutionary architecture already built for other characteristics (fitness functions, executable guardrails) should be reusable for comprehension too — which is exactly the move the article makes next, without the article explicitly flagging this as an inference from the two-altitudes evidence to the toolkit-reuse strategy.

Running spec-anchored SDD, TDD, and architectural fitness functions together — rather than practicing any one in isolation — is what produces a queryable context store capable of closing the AI comprehension gap. strength: medium

Explicit premises:

Spec-anchored SDD establishes the intent layer, with the spec authored and reviewed like code and amended when reality diverges from it.
TDD establishes the behavior layer, with failing tests written first serving as both the agent's brief and the verification of its output.
Architectural fitness functions establish the structural layer, as automated CI-blocking checks of architectural conformance.
None of the three disciplines is new individually — each already has an established literature and tooling (Beck's TDD, Ford/Parsons/Kua/Sadalage's evolutionary-architecture fitness functions, domain-driven design's ubiquitous-language tradition for specs).

Implicit premises:

The three disciplines' artifacts, once persisted and versioned together in the repository, compose into something qualitatively more than their sum — i.e. it is the integration itself, not any single discipline done well, that turns three separate practices into a "store."
A human reviewer's PR-level question about why the system behaves a certain way can always be traced to one of exactly these three artifact types (spec, test, fitness function), implying the three layers are jointly exhaustive of the "why" a reviewer or agent would ever need.

Inferences:

If the three layers really are jointly exhaustive of comprehension's "why," then a codebase missing any one of the three disciplines has a structural blind spot in precisely the dimension that discipline alone would have covered — e.g. no fitness functions means structural conformance has no persisted record even where intent and behavior are well captured.

Architectural conformance should be enforced by automated, CI-blocking fitness functions rather than left to human reviewers, freeing reviewer time to interrogate intent rather than check structure. strength: medium

Explicit premises:

Senior-reviewer capacity in AI-accelerated codebases is finite.
Cognitive overload slows teams down and increases failure rates.
A synchronous architecture review board, or a single senior engineer who catches everything, is slow, burns that person out, and lets architectural drift surface only when production exposes it.

Implicit premises:

Architectural conformance is the kind of property that can be fully captured by automatable, executable checks — implying there is no residual architectural judgment call that only a human reviewer, and not a fitness function, can make once the sensors are in place.

Inferences:

If some architectural judgments genuinely cannot be reduced to executable fitness functions — for example, whether a new bounded context is actually warranted, as opposed to whether an existing dependency rule was violated — then offloading "structure" entirely onto sensors while reviewers focus on "why" risks silently losing exactly that residual judgment, a limitation the article does not discuss.

Narratives

GitHub Copilot's 2023 Microsoft Research study reporting a 55.8% task-completion speedup became "the working definition of what AI does to software development" through vendor decks and hiring plans; two years later, METR's randomized controlled trial on experienced developers in their own large codebases found the opposite — developers were 19% slower, while believing themselves 20% faster.
→ Implicitly supports the proposition that raw code-production speed is the wrong thing to optimize for or measure, motivating the pivot to comprehension as the article's real subject.
Amazon's March 2026 storefront outages were traced to AI-assisted changes merged without proper review, prompting a code safety reset and a new senior-engineer approval requirement for all AI-assisted code — a procedural fix that, the article argues, sits one layer above the untouched structural problem of nobody holding the reasoning behind the changes.
→ Implicitly supports the claim that the context gap has real, visible organizational consequences at the team altitude, and that procedural reactions (approval gates) treat the symptom rather than the cause the context store is meant to fix.
A reviewer asking why a service rejects requests over 5MB finds the spec, the test, and the fitness function that jointly explain the constraint, all in the repository — and an AI agent picking up the same feature a quarter later starts from that same spec and fitness-function catalog rather than reconstructing the reasoning from scratch.
→ Concretely illustrates what the abstract four-layer context store cashes out to in an ordinary review moment, grounding the framework's payoff in a recognizable, mundane scenario rather than leaving it abstract.

Questions addressed

✅ What happens to an organization's understanding of a system when AI accelerates the writing of the system's code?
The understanding no longer ships automatically with the code; it must be deliberately captured and persisted through a context store fed by spec-anchored SDD, TDD, and fitness functions.
⭕ Why do developers report feeling faster with AI tools even when controlled studies (METR) show they were measurably slower?
The article names the 39-point perception gap as a symptom but does not explain the underlying causal or psychological mechanism behind the mismatch between felt and measured productivity.
✅ How should architecture practice change now that architectural characteristics must be enforced at AI-generation speed rather than at human-typing speed?
Run spec-anchored SDD, TDD, and architectural fitness functions together as one verification system so conformance checks run continuously in CI rather than depending on a human reviewer's read-through pace.
⭕ If spec-authoring and review must scale to match AI-generation speed the same way code review currently cannot, does spec-authoring capacity become the next finite, overloaded resource — just as senior-reviewer capacity already has?

Gaps

incompleteThe article treats finite senior-reviewer capacity as the crisis that pushed conformance checking onto automated fitness functions, but never asks whether spec-authoring capacity is symmetrically finite. The social practice it prescribes for spec-anchored SDD — "the spec is authored and reviewed like code, with diffs and approval, and amended when reality diverges from intent" — reintroduces a human bottleneck at the intent layer even as it removes one at the structural layer. If spec review cannot keep pace with AI-generation speed any better than code review currently does, the context store risks simply relocating the reviewer-capacity crisis from PRs to specs rather than resolving it.
Read next: Read against extract-eisele-ai-coding-agents-need-clear-specs' U-shaped cost curve of specification completeness (heavier specs front-load human effort) and extract-agentic-code-review's documentation of reviewer capacity already collapsing under AI-generated PR volume, to test whether spec-authoring is next in line for the same collapse.
incompleteThe Amazon outage is presented as an outcome of the exact context gap this article diagnoses, but the article's own cited source (CNBC) attributes the outage to "changes merged without proper review" — a review-gate failure — not to a documented absence of persisted intent, behavior, or conformance records specifically. The causal attribution to the context gap, versus a more generic review-diligence lapse, is asserted rather than demonstrated from the available reporting.
Read next: Follow further Amazon incident reporting or post-mortems, if published, to see whether investigators identified a missing intent/behavior/conformance record specifically, or a simpler story of a skipped approval step that a context store would not by itself have prevented.
incompleteThe article's context store distinguishes a machine-readable knowledge graph from a human-readable system spec, but doesn't interrogate whether prose-form specs can actually carry the relational structure that intent needs — priorities among constraints, non-negotiables versus preferences, time-bound versus principled rationale. This is the same gap the corpus has already flagged in Osmani's intent-debt series: existing artifact formats (specs, AGENTS.md, ADRs) may be "flat" against intent's real structure. The two-projection move is a step toward richer structure but stops short of specifying what the knowledge graph's schema actually captures that a flat spec would miss.
Read next: Read against extract-osmani-intent-debt's gap on intent-as-data versus intent-as-prose, and knowledge-representation literature (description logics, semantic web) on what a genuinely structured, queryable intent schema would need to encode.

Closes gaps elsewhere

Applying Best Simple System for Now for Software Design · g3 — Provides substantive engagement with evolutionary architecture and fitness functions (Ford/Parsons/Kua/Sadalage) as a complementary mechanism for keeping systems adaptable, applied specifically to the AI-comprehension problem that the other document left unaddressed.
Architecture as Code to Teach Humans and Agents About Architecture · g5 — Explicitly engages the prior art that gap flagged as missing — Ford, Parsons, Kua, and Sadalage's evolutionary architecture and fitness functions, ArchUnit, and dependency-cruiser — situating 'architecture as code' as an application of an existing toolkit rather than presenting it as novel.
The Intent Debt · g4 — Offers a concrete structural answer to the intent-as-data versus intent-as-prose question: the context store's four layers (structure, lineage, behavior, conformance) project into both a machine-readable knowledge graph that agents and CI jobs query and a human-readable system spec, rather than leaving intent as flat, undifferentiated prose.

Comprehension at AI Speed: Building a Context Store for Evolutionary Architecture

Structure

Key terms

Propositions

Arguments

Narratives

Questions addressed

Gaps

Closes gaps elsewhere

Related documents