Build for the Maintainer, Not the Moment

“Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.” —John F. Woods, 1991

That joke has quietly shaped engineering culture for thirty years and worked for a reason nobody says out loud: the psychopath was real. He was you, six months later at 3 am, reading your own clever abstraction with an incident bridge open in another window. The author and maintainer were usually the same person separated by a few quarters. Every shortcut was a loan against your future sleep.

Maintainability was never really a principle. It was self-defense.

That matters now because the enforcement mechanism broke. A growing share of your platform’s code is written by authors who will never be paged, sit the rotation, or meet the psychopath. The advice in the joke still holds. The threat that made anyone follow it is gone.

The Ledger Was Always Lopsided

Start with the economics the joke was protecting you from. A line of code is written once but read, debugged, extended, and worked around for years. Write-time is the smallest part of a line’s total cost and the only part the moment sees. The demo rewards what ships today. The maintenance bill arrives quietly and forever, addressed to someone else.

That’s why every line of code is a liability before it’s an asset. The feature is the loud part. The years of comprehension it demands from everyone who touches it afterward are the costly part. The moment is cheap and loud, but maintenance is costly and silent.

None of this is new, and stating it has never once changed anyone’s behavior. What changed behavior was the next part.

The Dread Was Doing the Work

Engineering organizations like to believe their code quality comes from values: the standards doc, the review checklist, the wiki page titled “How We Write Software.” It mostly doesn’t. It comes from incentives so old they’re invisible. The oldest is that authors expected to live with their own choices.

You wrote greppable code because you would be the one grepping it. You resisted the clever abstraction because you’d met your own cleverness at 3 am before and lost. You documented the weird workaround because you knew from experience that in eight months you would remember nothing. The on-call rotation, the team that inherits its own merges, the six-months-later self: these weren’t just operational structures. They were the enforcement arm of every maintainability principle you’ve ever read.

That’s why folk wisdom was always visceral rather than procedural. Nobody threatens you with a checklist. Woods didn’t say “code according to the standards document.” He said the maintainer knows where you live because the discipline only worked when the author had an address.

The Author Left the Building

Agents don’t have one.

The agent that wrote last night’s pull request will never be paged for it. It has no future self to protect, no on-call shift to dread, no reputation among peers who will inherit the module. It experiences the moment: the ticket, the diff, the green build. Nothing after. Every incentive that produced maintainable code lives in the after, and the after no longer exists for a growing share of your authors. If you object that you’re still the author because you prompted it, fine. Then you’re the maintainer too and already know which half of that job you’ve been skipping.

Agents completed a trend, not started one. High-churn teams, rotating contractors, and reorg-shuffled ownership had already separated authors from consequences for years. Ask anyone who has inherited a codebase whose entire authoring team has left the company. Agents took that separation to its limit and made it the default. The loan against future sleep is still taken out with every merge. The borrower no longer exists when the payment is due.

The maintainer, meanwhile, is more real than ever. Someone still gets paged. Someone still opens the file at 3 am. That person now inherits code written faster than ever, by authors who cannot be threatened, in volumes no rotation has seen before.

From Culture to Structure

If dread enforced the discipline and dread is gone, the discipline must move somewhere that doesn’t require anyone to feel anything. There are four places to put it.

Make the standard executable or admit you don’t have one. Complexity ceilings, dependency rules, API surface budgets, and mandatory documentation for public interfaces should be encoded as checks that fail the build. Principles that live in a wiki were enforced by authors who cared about their future. Your new authors don’t have futures. A standard an agent’s output can’t violate without a red build is a standard; everything else is a preference.

Turn review into inheritance. The reviewer was always implicitly a future maintainer. Make it explicit: approving a change means adopting it. Your name, your module, your pager. When the author can’t own the consequences, the approval must own them, formally and traceably. Unowned approval of unowned code is how a platform fills with orphans.

Optimize for the reader by policy, not preference. Boring, greppable, idiomatic code was the author’s gift to their future self. Now nobody’s future self is asking. So it becomes policy: clarity standards enforced at merge, naming and structure conventions checked by gates, documentation as part of done rather than a virtue. The reader is the only human left in the loop. Everything about the code should be priced for them.

Make deletion a first-class practice. The cheapest code to maintain is the code you removed. When authorship is nearly free, code accumulates by default. The only counterweight is deliberate: sunset reviews, usage-gated retention, and the standing question “what did we delete this quarter?” A platform that only adds is a maintenance bill that compounds.

None of these require inventing anything. They require admitting that what looked like culture was actually an incentive structure and rebuilding it so the incentives now live in the gates, the ownership model, and the merge path.

The Psychopath Is Still Coming

Woods was right about everything except the mechanism. Someone violent with exhaustion will absolutely end up maintaining your code at 3 am during an incident, and they deserve every protection the joke was trying to buy them. What’s changed is that fear no longer does the buying. The author the joke was aimed at has left the building, and no amount of reciting the quote brings back the dread that made it work.

Build for the maintainer anyway. Not because the author fears them (the author can’t) but because you’ve replaced fear with structure: standards that fail builds, approvals that confer ownership, code priced for its readers, deletion practiced on purpose.

The moment no longer needs your protection. The maintainer never needed it more.