Most of what we called seniority was never judgment. It was throughput and recall, priced as wisdom because both were scarce. AI made both cheap overnight, and the market has not finished repricing the ledger.
Date: July 2026 | Builds on: The Coder is Obsolete
The Signals That Just Got Repriced to Zero
Seniority was always inferred, never measured. Nobody could see your judgment, so the industry settled on proxies that correlated with it and were cheap to observe.
Two proxies did most of the work. Throughput: the person who cleared the ticket before lunch was the strong one. And recall: the person who knew the framework’s edge cases without opening the docs got deferred to in design meetings.
Both proxies were honest for a long time. You could not type fast without having typed a lot, and you could not recall the config surface of a large framework without having been burned by it. The proxy carried real information about experience.
AI severed the correlation without touching the signal. A mid-level engineer with a good harness now clears the ticket before lunch and knows the framework’s edge cases, because the model knows them. The output looks identical. The experience behind it does not exist. Every hiring loop, promo packet, and standup that reads those two signals is now reading noise.
This is not a claim that senior engineers are finished. It is a claim that a specific group is exposed: people whose title rested on being fast and well-read rather than on being right about hard calls. They have not lost their skills. They have lost the scarcity that made those skills legible as seniority.
What Got Repriced Upward
The interesting half is what became more valuable, not less.
Problem framing, because the cost of building the wrong thing went up. When implementation was slow, a bad framing got caught. Someone hit week three, felt the friction, and asked whether this was the right thing at all. The slowness was an accidental checkpoint. Now the team ships the wrong thing in four days and the checkpoint never fires. Framing used to be a nice-to-have that the schedule corrected for. It is now the last line of defence, which is the argument in AI Can’t Have the Hard Conversation.
Operational cost estimation, because generated designs are elegant by default and the model does not carry the pager. An agent will hand you a design that is genuinely clean and quietly commits you to a queue, a new datastore, and a failure mode that only shows up under partial network partition. Nothing in the diff says “this is now something a human wakes up for.” Reading that off a design you did not write is a distinct skill and it is not one AI has.
Comprehension, which used to be a free byproduct and is now a line item. The old workflow forced understanding as a side effect of typing. That is gone. Comprehension debt is the name for the gap, and the thing worth noticing here is that a junior can now generate code faster than a senior can audit it. The review bottleneck that used to manufacture comprehension for free has inverted.
The Delete Instinct
Here is the one I think is most underrated, and the sharpest test of whether someone’s seniority is real.
Reviewing generated code is the default move, and it is frequently the wrong one. Review is what you do to code that is close. You read it, you leave comments, you negotiate it toward correct. That workflow assumes the expensive thing in the room is the code, because a human paid for it in hours and throwing it away burns those hours.
That assumption is dead. The code cost nothing. Your attention is the only scarce resource in the transaction. When you spend forty minutes reviewing a generated implementation that is 70% right, you have not saved the forty minutes it would have taken to regenerate against a better spec. You have spent your scarcest input on the cheapest artefact in the system, and you have usually ended up with something worse than either a clean regeneration or a hand-written version, because negotiated code inherits the model’s framing plus your patches.
The senior move is to look at a generated diff and ask which of three buckets it falls into. Ship it, because it is right and the blast radius is small. Delete and respecify, because the output being wrong is evidence the spec was wrong, and patching the output leaves the bad spec in place to generate the same wrongness next week. Or delete and write it myself, because this is load-bearing and I need the theory in my head, not on the screen.
Almost everyone skips the middle bucket. It feels wasteful and it reads as indecisive in front of a team. It is neither. A wrong output is the cheapest possible signal that your specification was ambiguous, and it arrived for free. Patching generated code is how you convert a free diagnostic into permanent debt.
Multiplying Without Becoming the Queue
The last one is organisational, and I think it is where the real senior scarcity will end up.
The obvious response to agent-driven throughput is that senior engineers become reviewers. Six engineers each generating three times their old volume, one person reading it all. This fails on arithmetic within a quarter. You become the queue, the team’s velocity becomes your personal reading speed, and you stop doing the framing work that was the actual reason you were valuable.
The alternative is to move your judgment out of the review step and into the substrate the team works inside. Encoded standards, harnesses, evaluators, the tests and invariants that answer questions without you in the room. This is the same move as stewardship over authorship, applied to a team instead of a codebase: you are not reviewing the output, you are architecting the conditions that make the output trustworthy.
Concretely, the leverage is in deciding which subsystems are allowed to be generated freely and which require a human theory-holder, then writing that boundary down. That is the disposability line, and holding it for six people is a senior job that does not scale with reading speed.
Where I Actually Sit
I am not writing this from above the problem. Across roughly 350,000 lines where most of the implementation was agent-written, my honest failure mode has not been generating too much. It has been reviewing when I should have deleted. Sitting with a 70% diff and negotiating it, because deleting felt like admitting the last hour was wasted.
The hour was already wasted. The only question left was whether to spend a second one.
One Sentence
AI did not lower the value of seniority, it deleted the proxies we used to detect it, and the fastest way to prove yours is real is to delete generated code that a lesser engineer would review.
Related
- The Coder is Obsolete. The Programmer is Not. – The coder/programmer split this note prices out
- Comprehension Debt Is Refinanceable – The inverted review bottleneck in detail
- Code Stewardship Over Authorship – What replaces authorship as the unit of ownership
- AI Can’t Have the Hard Conversation – Framing as the surviving human job
- Which Code Is Allowed to Be Understood by Nobody – The boundary a senior engineer holds for a team
- The 30% Cliff – Why seniority alone does not save you past the prototype
