Accountable Generation: Intent as the Artifact of Record

Every serious engineering organization has spent decades building governance around one artifact: source code. Code gets version control. Code gets review. Code gets sign-off before it ships. The apparatus assumes that code is where human judgment lives — because for as long as software has been an industry, it was.

AI-assisted generation breaks that assumption. When a system can produce thousands of lines of plausible code from a structured description of what should exist, code stops being the expensive artifact. What becomes scarce is the intent: the human decision about what should be built, under which constraints, and who takes responsibility for it.

I run an AI-native delivery operation where agents produce most of the code, and this essay is the conclusion that operating it forced on me: the artifact of record should be the intent, and code should be treated as governed output.

Cheap code breaks the review model

Code review became the center of engineering governance for a good reason. Code was the crystallization of human thought — slow to produce, dense with decisions, and the last place a mistake could be caught before it became behavior. Reviewing the code was reviewing the thinking.

Generation changes the economics on both sides at once. Output volume grows faster than any team's capacity to read it, so line-by-line review of generated code cannot keep up. Less obviously, it also stops catching the errors that matter. When code is generated, the defect is rarely a misplaced line; it is a wrong or missing decision in what the system was asked to do. Reading the output harder will not find a flaw in the request.

This is not an argument that code review is dead. It is an argument that the object of review has to move up a layer: from "is this code correct?" to "is this intent right — and can we verify that the generated system honors it?" The second half of that question is genuinely hard, and I return to it below.

The depreciation test

There is a question I now apply to every asset in an AI-assisted engineering stack: when the models get better, does this appreciate or depreciate?

Most of what the industry is building today sits on the depreciating side. Anything whose value proposition is "produce code more cheaply" — scaffolding tools, template libraries, intermediate layers whose main job is saving generation effort — loses a slice of its value with every model release, because frontier models keep absorbing exactly the work those layers were created to save.

Intent as a governed record sits on the other side — but for a narrower reason than "humans write the specs." Models can help draft specifications too; intent production is not immune to automation. What a model cannot supply is accountability. It cannot take responsibility, cannot sign, and cannot answer to an auditor or an incident review. As generated code approaches free, the scarce layer is not writing intent — it is owning it. Governance attached to the ownership layer appreciates for the same reason tooling attached to the output layer depreciates.

The test is worth keeping even if you reject every other claim in this essay. Run it on your own toolchain and roadmap: which of the things you are building would a better model simply absorb?

What "artifact of record" actually means

An artifact of record is not a document that happens to exist somewhere. It is the artifact your organization treats as authoritative — the one governance actually attaches to. Intent becomes the artifact of record when four things hold:

• Versioned. The specification has history. You can see what the system was supposed to be last quarter, and who changed that.
• Diffable. A change to the system is expressed as a change to the intent — a readable diff of decisions, not ten thousand lines of regenerated output.
• Audited. When someone asks why the system behaves the way it does, the trail ends at a recorded human decision, not at a generation log.
• Signed off. Approval happens at the intent layer, where the approver can understand what they are approving.

None of this demotes code to irrelevance. Code remains what runs, what fails, what gets attacked; it must still be tested, scanned, and inspected — and at generation volume, that verification is a serious cost in its own right, not a footnote.

The end state this describes is the relationship source code has to compiled binaries: the artifact downstream is verified and deployed, but authority lives upstream. I have to be honest about what that analogy assumes. Compilation is deterministic; generation today is not. Regenerating from the same intent does not reliably produce the same system, which means intent-level diffs and rollback are currently aspirations carrying engineering debt, not properties you can buy. Two open problems stand between the current state and the end state: regeneration determinism, and intent verification — how to check that a generated system honors its intent without re-reading every line. Tests and properties derived from the intent are the obvious candidates; calling either problem solved would be dishonest. What this essay claims is narrower and does not have to wait: governance should attach to the intent layer now, because an organization that waits for these problems to be solved will spend the intervening years shipping systems whose reasons nobody recorded.

Where this matters first: regulated contexts

There are environments where this shift is optional for now — and environments where it is the entire question. In finance, healthcare, and government systems, "the agent did it" is not an acceptable answer. An auditor, a regulator, or an incident review board needs the trail to end at a human-readable record that a named person approved.

Regulated engineering will recognize part of this argument immediately, because it has governed intent artifacts for decades: requirements baselines, change requests, traceability matrices. The disciplines exist and the budgets behind them are real. What generation changes is the direction of authority. A requirement used to be a document that traced — with human effort and constant drift — to code that people wrote by hand. When the specification is what generates the system, the trace stops being an overlay maintained after the fact: the record of intent and the source of the software become the same artifact. That is not a new compliance discipline. It is the old one, finally attached to the layer it always wanted to govern.

I should be precise about the status of this claim: it is an argument about fit, not a reported result. But it asks regulated organizations to extend a discipline they already fund, not to adopt something foreign.

How I run this today

My own delivery operation runs on this model, at small scale. Every material decision lands in an append-only ledger with its context and its alternatives. Work does not count as done when tests pass; it counts as done when it clears gates that demand evidence rather than assertion. Sign-off happens at the intent layer, and the record of who approved what — and on what grounds — survives the code that implemented it.

That is practice, not proof: one small operation, run by the person making the argument. I offer it because it shaped the position through delivery rather than through writing, and because it makes the closing questions concrete instead of rhetorical.

If you want to know where your own organization stands, three questions get to the point quickly:

1. Does your specification have a version history — or is it a slide deck that was last accurate at kickoff?
2. When an approver signs off on a release, what are they actually reading?
3. When something goes wrong, which layer does your audit trail point to — a recorded human decision, or a pile of generated code nobody wrote?

Code used to be expensive, so we governed code. Code is becoming cheap, and governance has not yet moved. The organizations that move their artifact of record to the intent layer will be the ones still able to answer the question accountability always comes down to: who decided this, and on what grounds?