"Context Debt" Is a Strawman

“A map is not the territory it represents.” — Alfred Korzybski

Here’s the pitch, and it’s a good one. Vibe-coded slop is only the symptom; the disease underneath is context debt — the steady loss of what the code means and how its parts connect. Your senior engineers carry that map in their heads, the argument goes, and heads don’t scale — so buy a living map instead: a Context Graph, a Context Lake, an always-on model of your services and their dependencies that grounds the AI in everything the code alone won’t tell it.

It names something real, then misdiagnoses it. The cure it sells, I’ll argue, is a silver bullet you can’t verify. The tell is in the pitch’s own premise.

Bottom line up front

• Context is a skill, not a stock. “Context debt” prices what you hold — a standing map of the system. But the value was rarely the holding; it’s the deriving — navigating the code to the slice a question needs. The stock is the cheap part (a map, a bigger window, a wiki all hold it); the skill isn’t for sale.
• Derive on demand; don’t buy a map. The structure is already in the code. Ask the AI to trace how the pieces connect, then check the trace against the source — the trace is a claim too. That’s the senior’s method, made cheap, not a product.
• Treat a bought map as a claim, not the ground truth. It’s a derivation someone else built that you can’t cheaply verify. Trust the raw over the summary.
• Own the connective tissue. What actually bites is integration code that got written and merged with no human reading or owning it. Read it. That fix isn’t for sale.
• Serve the right slice. Retrieve or derive the part the question needs; don’t pour in the whole thing. More in the window is not more understanding — not for you, not for the model.

Nobody held the whole map

Start with the premise: senior engineers hold the map in their heads, and that doesn’t scale. Part of it is true. Knowledge walks out the door when people leave, and plenty of it was never written down. But the load-bearing part is false. Almost no senior holds the whole map of a large system. What a senior actually does is keep the small slice that’s relevant right now and derive the rest on demand — open the file, follow the call, read the integration when the question comes up. Ruven Brooks argued this in 1983: expert program comprehension is top-down and as-needed, a hypothesis you check against the code, not a full model held in memory. Scale never broke the method, because the method was never “memorise everything.” It was “know how to find out.”

That’s what debt smuggles in — a stock you hold and maintain, when the thing that scaled was the skill of deriving on demand. And AI sharpens that skill rather than retiring it: with the tracing gone cheap, the senior’s job moves up a level — to directing the derivation: which slice the question needs, and whether to trust the trace it hands back. The stock got cheaper to hold. The judgment is still yours.

And here’s the part the pitch inverts: AI makes derive-on-demand cheaper, not harder. On one migration I never held the whole map in my head. Each time a decision came up I asked how the current version actually behaved — how it returned results, what it locked down — and had the AI trace it straight from the live source; I built on what it read, not on what I remembered. When I doubted the rewrite would even come out smaller, I had it count the lines across all twenty-odd files of the old version. The map was in the code. I derived the slice I needed, each time.

That’s the whole move. Ask how the payment flow connects, get an answer in seconds, then verify it against the code. The thing the vendors sell as the cure is already the tool that makes the supposed disease manageable.

The map is in the code

The load-bearing claim under the pitch is this: “the debt isn’t in the code — it’s in what the code means and how it connects.” Half of that is real, and half is sleight of hand. Much of the structural connection — the call graph, the data flow, the contract between two services — is in the code, derivable from the source (config, dynamic dispatch, and deploy topology aside), because the source is what produces the behaviour. What isn’t in the source is the why: the intent, the operational lore, the reason a given retry is there. That layer is real — and it’s exactly where the pitch breaks, because an auto-generated map can’t recover it either. A Context Graph indexes the derivable, structural part; the tacit why lives in people and docs, and a map you never feed those can’t invent them. So it hands you the part you could already derive and misses the part you actually needed a human for.

Even the structural part is only a cached derivation of the code — useful the way any index is useful, but authoritative only while it still matches the raw. The vendors half-admit it: buried in the same pitch is the concession that a stale map can be worse than none, because the agent acts on it with full confidence. Their answer is that the map is always-on, continuously synced. That doesn’t save it. You can verify a scoped trace against the code it came from; you can’t wholesale-verify a standing map of the whole system, so you end up trusting it. Sync lag and derivation error don’t vanish because you refresh more often. Fast or slow, it’s a cache you’re trusting over the raw — drift with a confident voice.

Bigger windows don’t hold the map

The measurements don’t cooperate with the big-window pitch. Chroma’s Context Rot study (2025) ran eighteen models and found performance degraded as the input grew — even when the fact the model needed was sitting right there in the context. “Lost in the Middle” (2023) is the positional version: put a fact in the middle of a long input and it gets overlooked. The middle of a big window is a death zone. And NVIDIA’s RULER benchmark found that a model’s effective context runs far short of its advertised window. Three studies, one lesson: a bigger container doesn’t mean the model holds more of your map.

So pour everything into one context and you don’t preserve the map — you give the rot more room to work. When a “context lake” retrieves the right slice for the question, it’s doing the senior’s derive-on-demand under another name; when it just dumps more in, it rots. The fix that tracks the evidence is the slice, not the lake.

The honest part

There’s a real problem under the pitch, and it deserves the credit. At machine speed, production can outrun comprehension — the AI can wire together more system than anyone has read.

But look at what it actually is. It’s the same disease Give Away the Writing, Keep the Reading is about — code shipped that no human read or owns — one level up: at the connective tissue between components instead of inside a single function. The AI wrote the integration; nobody read it; now no one knows how it hangs together. That’s less a missing-map problem than a missing-read one, and it should never have been allowed through. The cure is the same: read the code that matters, own it, and point your attention where the system actually churns — the hotspots, in Tornhill’s sense, not every file equally.

Pay it down by reading

“Context debt” takes that real problem, renames it a disease, and sells you a map you can’t trust in place of the reading you should have done. The debt that bites is the code nobody read and no one owns. You don’t pay that down with a map. You pay it down by reading.

---

How sure I am: the context-window limits (Chroma, Lost in the Middle, RULER) and the derive-on-demand model of comprehension (Brooks) are prior art, cited below; the migration where I derived each slice from the live source is my own experience; the core claim — that a bought map is a cached derivation you can’t cheaply verify, so deriving on demand beats buying one — is a wager, argued and not measured. If this is wrong somewhere, it’s there.

Sources

• Burns, “Vibe slop is the symptom. Context debt is the disease.” (The New Stack, 2026) — the “Context Graph” pitch this piece rebuts; source of the “it’s in what the code means and how it connects” claim and the admission that an out-of-date map can be worse than none. https://thenewstack.io/vibe-coding-context-debt/
• Bridgwater, “‘Vibe coding slop’: Port’s CEO on the problem with ungoverned AI dev” (The New Stack, 2026) — the “Context Lake” / big-window pitch the essay turns against itself. https://thenewstack.io/port-ai-builder-governance/
• Brooks, “Towards a Theory of the Comprehension of Computer Programs” (1983) — expert program comprehension is top-down and as-needed: keep the relevant slice and derive the rest, rather than holding the whole map in memory.
• Chroma, “Context Rot: How Increasing Input Tokens Impacts LLM Performance” (2025) — eighteen models degraded as input grew, even when the needed fact was present in the window. trychroma.com/research/context-rot
• Liu et al., “Lost in the Middle” (2023) — facts placed in the middle of a long input get overlooked. arXiv:2307.03172
• NVIDIA, “RULER” (2024) — a model’s effective context runs well short of its advertised window. arXiv:2404.06654
• Tornhill, Your Code as a Crime Scene (2015) — point attention at hotspots (churn × complexity), not every file equally; the basis for CodeScene.

---

Extends Give Away the Writing, Keep the Reading to the system level — the seam between services, not just inside a function. The derive-on-demand skill is Thinking at the Speed of Code applied to context.