The archaeology
The email is polite. It is always polite. A due-diligence questionnaire from your largest customer, or the ISO 27001 surveillance audit, or internal audit’s annual sweep of systems in scope. Somewhere in the middle of it, a question that reads as routine and lands like a depth charge:
“Describe why [system] is architected as it is, including key design decisions, alternatives considered, and approval.”
What happens next, in most organizations, is archaeology. Two weeks of it. Slack exports. A Confluence page last edited three years ago by someone who has left. A diagram that contradicts the deployment. And the one engineer who was actually there — pulled off delivery to reconstruct, under pressure, a narrative that everyone assembling it quietly knows is part memory and part plausible fiction.
The audit usually passes. The cost lands anyway: senior people lost to excavation for weeks, and an institutional awareness that is worse than any finding — you can produce evidence, but you do not possess it.
Decision debt
Name the liability properly. Technical debt is the gap between the code you have and the code you would want. Decision debt is the gap between the decisions you have made and the decisions you can prove.
Like all debt, it is invisible while you are accumulating it and expensive on the day it is called. Audits, incident reviews, customer due diligence, and the departure of senior engineers are the collection events. Where technical debt slows delivery, decision debt concentrates risk: it converts routine questions — why is it built this way? who approved this boundary? — into research projects with regulatory deadlines attached.
Every engineering organization carries some. What changed in the last two years is the rate of accumulation, through two mechanisms at once.
More decisions per week. AI coding agents make architectural micro-decisions constantly — a library adopted, a retry pattern chosen, a boundary drawn — in sessions that last minutes and run in parallel across every team. The decision rate has multiplied. The recording rate stayed where it always was: close to zero.
Fewer rememberers. The recovery mechanism for unrecorded decisions has always been human memory — archaeology works because someone was there. For agent-made decisions, no one was there. There is no engineer to pull off delivery, because no human made the call.
Meanwhile the questionnaires are evolving. Due-diligence and security-review templates have started growing a line that did not exist two years ago: how is AI-generated code governed, and how are its decisions traced? You are accumulating the new class of debt at precisely the moment the collectors are learning to ask about it.
The reconstruction drill
Twenty minutes, no tooling, one system. Run it yourself before someone with a clipboard does.
The reconstruction test
Pick one production system in scope for your next audit. Set a twenty-minute timer. Using artifacts alone — repositories, docs, tickets; no asking people — write the auditor’s answer for the system’s single most consequential architectural choice: what was decided, when, by whom, and what alternatives were considered. Grade it the way an auditor would: names, dates, and reasoning, or it does not count. If the timer beats you, that is the size of the debt on one question about one system.
The leaver test
List the systems where that answer lives mainly in one person’s head. Put actual names against actual systems. Now read the list as what it is: single points of evidentiary failure, each with a resignation-shaped trigger. If a name on that list left tomorrow, the archaeology for their systems would no longer be slow — it would be impossible.
The provenance test
Take one AI-assisted change that shipped into a regulated path. Can you show what constraints the agent was operating under when it wrote the code — what standards it was given, what decisions it made along the way? This is the question the questionnaires are learning to ask. Today, in almost every organization, the honest answer is no.
If the drill went badly, resist the reflex to blame discipline. Your teams do not decide carelessly; they decide quickly, and recording is a separate act — performed after the interesting part is over, by people with delivery pressure, into a system nobody reads. Separate acts get skipped. That is not a character flaw; it is a design flaw in where the recording happens.
The only decision records that reliably exist are the ones produced as a by-product of the work itself.
Records as by-products
That principle is the design brief for what we call the document plane: a versioned layer between intent and code where decisions are captured at the moment they are made, by the same tools doing the work.
For humans, that means architecture decision records living in git, next to the code they govern — timestamped, attributed, diffable. Git history is itself an audit trail; a decision recorded there carries its own provenance for free.
For agents, it means the connection runs both ways. The same protocol that delivers your standards into an agent’s context carries decisions out: an agent that adopts a library or draws a boundary records that decision into the versioned layer as it works. Nobody reconstructs anything afterwards. The ledger accretes as a side effect of shipping — which is the only accrual model that survives delivery pressure.
This is what we are building with SystemDox. Concretely, for a regulated organization:
Decision capture in the workflow. Agents connected over MCP pull standards and checks before they write, and record architecture decisions as they make them — the provenance test gets an answer by construction.
Evidence that lives in git. Specs, decision records, and checks are versioned with GitHub as the source of truth: every claim in your evidence room has a commit, a date, and an author.
Staleness detection. Repository scanning flags documentation that no longer matches the code it describes. For audit evidence this matters more than anywhere else: an assertion that no longer matches production is worse than no assertion at all.
Sanitized publishing. Every publish is scanned for credentials, PII, and internal infrastructure before docs leave the boundary, with sensitive values redacted against an encrypted vault — because the other audit failure mode is evidence that leaks what it should not.
UK data residency. Hosted in AWS eu-west-2 (London), for organizations whose regulators care where the evidence lives.
The posture shift is the point: from “we can produce a narrative” to “the ledger already exists.” Those are different companies to audit, and auditors know it within the first hour.
What this does not fix
No tool makes you compliant, and you should distrust any vendor who says otherwise. Compliance is process, controls, and judgment; this is the evidence layer underneath them — necessary, not sufficient. The document plane records what flows through it: decisions made in hallways still need a human to write them down. What changes is the default — the fastest-growing class of decisions, the agent-made ones, gets captured automatically instead of not at all. And none of this is regulatory advice: your compliance team still owns the mapping from evidence to obligation.
Start here
Run the reconstruction drill this week — twenty minutes, one system, honest grading. You will know your debt position before the next questionnaire computes it for you.
Then instrument the system you would least like to be asked about: connect the repository, publish its standards and decision records through the document plane, point the agents working on it at the same layer, and let the ledger start accreting. SystemDox’s free tier covers one repository, permanently; regulated organizations usually want the wider conversation about workspaces, access boundaries, and publishing controls — that is a demo.
An audit is just a question you knew was coming. Decision debt is choosing to answer it from memory.