"I Shipped This"

In The Ego Left the Codebase I raised the accountability problem and resolved it in about two sentences: ownership stays with the person shipping the thing. Easy to write. Much harder to do, because “the model did it” is the most natural shrug in the world, and every incentive points toward shrugging. This post is about what the practice of ownership looks like when nobody typed the code.

The standard I keep coming back to is the signature. You don’t merge what you can’t explain. Not reproduce, explain, line by line if someone asks. The test for whether you own a diff is whether you could defend it with the model turned off. That sounds obvious until you’re twelve merges deep on a Tuesday and the code works and the explanation would take an hour you don’t have. The discipline is exactly as boring as every other discipline that matters, which is to say it’s a habit, not a principle, and habits are built on the days you don’t feel like it.

Review is the second piece, and it moves in the opposite direction from what people expect. It doesn’t relax because a model wrote the code. It tightens, for two reasons. Volume went up, so more code is arriving at the gate per unit of scrutiny. And the thing under review changed: it’s no longer the syntax, which the model gets right with annoying consistency. It’s the author’s understanding. A review comment like “walk me through why this lock is safe” used to be pedantry. Now it’s the entire point.

The third piece is blame, and I mean that word without drama. When AI-written code takes down production, the postmortem should name a person, and everyone should have known whose name it would be before the incident, not after. Accountability assigned after the fact is theater. Assigned in advance, it changes behavior on the way in, which is the only time behavior can change.

I run the solo version of all this, which is both harder and more honest. There’s no team to insist on the standard, so the insisting is self-imposed.

Now the objection worth sitting in, because it’s better than it first sounds: maybe authorship-based accountability is the wrong frame entirely. We don’t ask a construction foreman to explain every weld. We hold them to outcomes and inspections. Aviation holds a pilot-in-command responsible without expecting them to machine the turbine blades. Maybe software is maturing into that, and demanding line-level understanding is nostalgia for a craft phase that’s ending. I think that’s right for some layers of the stack and catastrophic for others, security and data handling being the obvious ones. A foreman who can’t explain the welds is fine. A foreman who can’t explain the load calculations is a collapse waiting for a date. The interesting question is where that line sits in software, and I don’t fully trust anyone’s answer yet, including mine.

Which leaves the unresolved part. This discipline only works if someone insists on it, and the insisting used to come from the social layer AI removed: the reviewer, the team, the culture that made “I don’t know, the model wrote it” an unacceptable sentence. A solo dev holding himself accountable is either the purest version of ownership or the least verifiable one. Probably both.