AI increased the supply of code, not the supply of ownership

There is a reasonable question behind a lot of hiring decisions right now: if an AI can write the code, why pay for a senior developer? It deserves a direct answer, because the honest one is not defensive. AI changed the economics of software in a real way. It just changed a different part than the question assumes.

AI made code cheap to produce. It did not make ownership cheap. And on any system that has to keep working, ownership was always the expensive part.

The bottleneck was never typing

Long before AI, studies of how developers actually spend their day kept finding the same thing: only a small fraction of it goes to writing new code. Most goes to understanding code that already exists — reading it, tracing it, working out what a change will touch and what it might break. Writing was never the bottleneck. Understanding was.

AI is genuinely good at the part that was never the bottleneck. It will produce a working endpoint, a plausible component, a hundred lines of test, in the time it takes to describe them. What it does not do is decide where that endpoint belongs, whether the rule it encodes already lives somewhere else, what happens when its assumptions meet the rest of the system, or whether the test it wrote checks anything real. Those decisions are ownership, and they got more important the moment code got cheap, not less.

Cheap code, faster drift

Here is the uncomfortable second-order effect. When producing code was slow, the slowness was a brake. You could not add ten half-considered features in a week, because you could not write them in a week. AI removes the brake. That is the upside — and it is also how a system can accumulate, very fast, the exact problem worth avoiding: the same rule solved three slightly different ways, in three places nobody chose on purpose.

More code is not more capability. More code with no decision about where each piece belongs is just more places for a rule to hide, more surfaces to keep in sync, more ways for the next change to surprise you. AI can multiply your output and, without an owner, multiply just as fast the rate at which the system becomes hard to change. The generated code compiles. It passes its generated tests. It looks like progress on every dashboard. And the cost of the next change climbs anyway.

Where the senior developer moved

So the role did not disappear. It moved — upstream and downstream of the typing that AI now does.

Upstream: understanding the business well enough to decide what should be built and where it belongs, so the AI is aimed at the right shape instead of guessing at it. Downstream: verifying that what came back is actually correct against reality, integrating it so it has one clear home, and keeping the system as a whole legible. Researchers studying AI-assisted teams have started calling this supervisory work — less writing, more directing, reviewing, and correcting. It is a fair description of what senior development was always mostly about, now that the typing has been automated away from it.

This is also where a specific trap lives. AI is very good at generating tests, and much of what it generates mocks everything it touches and asserts on shape rather than behaviour — green coverage with no anchor. A green test suite is not the same as safety, and AI makes false-green cheap to manufacture by the hundred. Someone has to hold the line on what counts as evidence. That someone is the owner.

The honest limit

None of this is an argument against AI. I use it, and using it well inside a bounded frame is part of how I work — the evidence-over-confidence standard on the values page applies to an AI's output exactly as it does to a memory or a doc: it is a signal, not the truth, until it is checked against the system. The point is not "AI bad, humans good." It is narrower and more durable: a tool that produces more code raises the value of the judgment that decides where code belongs and whether it is right. The scarce resource is ownership, and it just became scarcer.

Why this is the offer

This is the work I take on when I own a system: not to out-type the AI, but to do the part it cannot — hold the business and the system together, decide where each change belongs, verify it against reality, and keep the whole thing a place where the next change stays easy. You can let AI write more of it. Someone still has to own where it all goes.