Legacy Code at Birth

The diff compiles. The tests pass. The agent has written a clean change — consistent naming, sensible structure, the kind of code you’d have signed off on a junior for without a second look — and somewhere in the back of your skull a small muscle relaxes. That’s done. I’ve felt that relief a thousand times across twenty-five years, and for most of them it was telling me something true. It isn’t anymore. The relief is the bug.

Because nobody you can ask wrote this. There’s no author to walk over to, no head holding the three constraints that aren’t in the diff, no person who’d wince if you asked the obvious question because they’d already thought of it. The code arrived without the thing that used to come attached to code: a mind that held the intent. What you have is a clean artifact and an empty chair. What you have, thirty seconds after it was generated, is legacy code.

Let me be exact about what kind of claim that is, because the whole series depends on my being honest about it from the first paragraph. “Agent output is legacy code at birth” is not a research finding. It’s the interpretation this collection sets out to defend — a reading derived from Michael Feathers, who defined legacy code not as old code but as code without the understanding that would let you change it safely. By that definition the agent’s freshest output qualifies the instant it lands on your desk: passing, fluent, and unaccompanied by anyone who knows why it does what it does. I’ll mark that line — this is the claim, not the proof — every time it matters. A series about accepting work you can’t fully verify owes you that much about its own central sentence.

The disclosure that makes the rest honest

This series was written by agents. The research was conducted by agents across thirty-five documents; the synthesis was drafted by agents; the prose you’re reading was generated and then accepted, line by line, by a human who put his name on it. I’m telling you this up front because the alternative is to argue that you should treat agent output as legacy code at birth while quietly pretending mine isn’t. The piece enacts its own thesis. I accepted this the way I’m about to spend six pieces describing — and where I couldn’t verify something, I said so, which is the only move that makes the lived parts of this worth your time.

That’s the posture, and you’ll see it recur in a specific shape: every piece will tell you, plainly, where the number my own argument wanted turns out not to exist. Not as a confession. As a discipline. The fastest way to lose a reader who knows the field is to claim more than the evidence carries, and the field this series walks through has more honest gaps in it than I expected going in. I’d rather hand you the gaps than paper them.

The skill isn’t new. The volume is.

Here is the part I want to get right, because it’s where most of the writing on this subject goes wrong in the same direction at once.

Accepting code you didn’t write is not a strange new task the agentic era invented. You’ve been doing it your whole career. Every time you inherited a service from someone who’d left the company, every time you reviewed a teammate’s pull request and stamped it, every time you opened a forty-thousand-line repository you were now on call for and started reading your way into a stranger’s decisions — that was acceptance. You stood at the boundary where responsibility for code crossed over to you from someone whose head you couldn’t get inside, and you took it on anyway. The contractor who left, the library you vendored, the system nobody’s owned since 2019: acceptance is the oldest furniture in the building.

What changed is not the skill. It’s the load on it. Acceptance used to be a thing you did in the margins — a slice of the week, a tax you paid on inherited systems between the real work of authoring. The authoring was the job; the accepting was overhead. The agent inverts that ratio. When generation gets cheap and fast, acceptance is no longer the tax on the work. It is the work. The slow, deliberate, judgment-heavy act you used to do at the edges has been pushed to the center of the bench, and the volume coming across it does not care that you only ever treated it as a side skill.

So this is not a bolt from the blue, and I’m going to be allergic to anyone who sells it as one. Nobody got blindsided. There’s no single competency you forgot to prepare for. What happened is quieter and harder to dramatize: a skill that was always part of senior work got loaded past the level you ever had to be good at it, and under that load the shortcuts you’d built for it stopped holding. The interesting thing isn’t novelty. It’s that the thing now under strain is old, and being old, it has been solved before — repeatedly, by people who never wrote a line of code.

The trade nobody put on your title

There’s a name for this skill, and it isn’t a software name, because software is the last field to need it at scale, not the first.

When you accept work other hands produced and put your name on it, you stop being the author and become the signer — and signing for work you didn’t make is a different craft from making it. It’s older than software by centuries, and at least five professions have practiced it to the point of ritual. The structural engineer who stamps a drawing he didn’t draft. The attending physician who countersigns the resident’s orders. The editor at the fact-checking desk who confirms a sentence she didn’t write. The auditor who samples a ledger he didn’t keep. The aircraft inspector who re-checks a repair another mechanic performed. None of them authored the thing they’re accountable for. All of them are more accountable for it than the person who did.

That last sentence is the whole series, so I’ll resist the temptation to rush past it. The trap waiting here — the one I’m going to refuse in every piece — is to read “you’ve been demoted from author to acceptor” as a loss. It isn’t. The engineer’s stamp is not a consolation prize handed to him after someone else got to do the fun part of drafting. The stamp is where the accountability lives, the judgment lives, the consequence lives. The drafter can be wrong and walk away. The one who sealed it cannot. Acceptance is not what’s left over when the machine takes the interesting work. It is the senior, irreducible, name-on-the-line work that was always the actual point of being the senior in the room — and the agentic era has done nothing but make it the majority of the job.

What it humbles, if you let it, is the assumption that twenty-five years made you a master of this particular skill. They didn’t, quite. They made me a master of authoring, with acceptance as a competent sideline I never had to push to its limit. Now it’s the main event, and I’m finding — this is the part you have to be able to laugh at — that the one skill I always filed under overhead turns out to be the job. Of course it does. So I’m doing what the situation actually calls for, which is going to school on it: watching the five trades that have run this exact problem for a hundred years, and stealing their methods.

What the machine strips, and where each piece picks it up

Here’s the map, and the rest of the collection is the territory.

The reason your inherited-code instincts don’t transfer cleanly to agent output is that machine authorship strips five specific things your acceptance shortcuts quietly depended on. Each one is a later piece.

It strips the author behind the surface. Your at-a-glance read of code quality was, it turns out, substantially a read of the author — clean code from a careful colleague meant a careful mind, and you trusted the mind. The agent produces the clean surface with no mind behind it, and the instinct keeps firing on nothing. That’s The Surface Lies, and the answer it borrows is the engineer’s stamp: own the production, never the appearance of it.

It strips your ability to see what isn’t there. Review is decent at catching the wrong line and near-blind to the missing one — the permission check never written, the edge case never handled — because an absence has no surface to land your eye on. Agents have a characteristic way of leaving things out. That’s The Thing That Isn’t There, and the answer comes from the fact-checking desk and the audit sample, two trades built entirely around hunting what’s missing.

It strips the manageable size of the thing you’re accepting. There’s a volume past which review stops working by construction, and the agent hands you that volume on demand. That’s You Can’t Read It All, and the answer is the discipline auditors and aircraft inspectors have practiced forever: decide in advance, and in writing, what gets read deeply and what gets sampled.

It strips the provenance — the plan, the prompt, the reasoning, the why. The agent had all of it during generation and threw it away at the handback, leaving you to reconstruct its intent from the artifact alone. And it strips the shared environment: the agent ran your code in a warm sandbox with the state seeded and the context fresh, then handed you a flat diff on the coldest desk in the building. Those last two are The Cold Desk, and the answer is a handback contract — the older trades simply refuse to accept work that doesn’t arrive in inspectable condition.

The recurring move underneath all five is the same one, and it has a name I’ll use sparingly so it doesn’t wear out: re-derivation. Not inspecting the artifact the agent produced, but rebuilding the intent it was supposed to be exercising — the thing the original author’s head used to hold, reconstructed by you, on purpose, because nobody else is going to. Every break in the list is a different way artifact-inspection fails. Every answer is a different discipline for re-deriving instead.

What I can’t tell you yet, and why I’m telling you now

I’ll end the way the collection ends, because the two bookends are the same honesty pointed in opposite directions. The opener names the trade; the closer admits its limits.

The limits are real, and they’re not small. There is no clean study comparing how senior engineers read agent-authored code against human-authored code matched for difficulty — the exact experiment this whole project would lean on, and it doesn’t exist. There’s no measured rate at which review misses an absence versus a wrong line. There’s no evidence-based rule for verified enough. The final piece gathers all of these and does not resolve them, because they don’t resolve. What it does instead is the actual answer the trade has always landed on: when the rules run out, what’s left is a person’s judgment under irreducible uncertainty, owning the named decision, accountable for the judgment and not the gesture. That’s not the gap in the craft. That is the craft.

For now it’s enough to have named the thing. The agent hands back clean, passing, authorless code, and the clean surface fools the part of you that learned, over twenty-five years, to trust it. What you’ve inherited is legacy code thirty seconds old, and accepting it well is the oldest senior skill there is, surfacing under a volume it was never tested at. The relief when the diff goes green is real. It’s just no longer evidence of anything. You read past it, you re-derive what the machine couldn’t hand you, and then you sign — because the name on the line is yours, and it was always going to be.

This is the frame. The first break begins with The Surface Lies — why your at-a-glance read of code quality was reading the author, not the quality, and what the engineer’s stamp does instead. From there: The Thing That Isn’t There, You Can’t Read It All, The Cold Desk, and the closing piece, What We Can’t Tell You Yet.