We're About to Stop Making Senior Engineers

TL;DR: For thirty years the way you became a senior engineer was boring and reliable: you did a pile of unglamorous work — the CRUD screens, the flaky-test triage, the “why is this query slow” afternoons — and somewhere in that pile your hands learned things nobody could have told your head. AI is exceptional at exactly that pile. So we’re about to get very good at producing code and very bad at producing the people who understand it. The gap between knowing an answer and having earned it is widening, it hits juniors first and hardest, and cutting juniors to “do more with AI” quietly burns the bench you’ll need in five years. The fix isn’t fewer juniors. It’s teaching them to be architects on purpose, instead of hoping it rubs off.

The ladder is losing its bottom rungs

Becoming a senior engineer was never really about the senior work. It was about the junior work, done enough times that it stopped being junior. You wired up the forms. You chased the null that only showed up in staging. You rewrote the same migration three ways before one of them didn’t lock the table. None of it was prestigious, and all of it was the curriculum. The architecture sense you wanted lived on the far side of a thousand small, tedious encounters with how systems actually behave when you connect them.

That’s the ladder. And AI is very good at the bottom rungs.

The optimistic framing — the one I mostly agree with — is that AI amplifies human judgment rather than replacing it. I’ve argued a version of that myself in response to Nadella. But “amplifies judgment” has an asterisk nobody likes to read aloud: amplification is multiplication, and multiplying by a junior’s judgment gives you a junior’s judgment, louder. Judgment isn’t a thing you can be handed. It’s sediment. It settles out of work, slowly, and the work it settles out of is precisely the work we’ve just handed to a machine.

Knowing is not doing, and the gap is getting wider

There has always been a gap between knowing how something works and being able to do it. You can memorize every design pattern in the catalog and still reach for the wrong one the first time a real system makes you choose. What’s new is how convincingly AI lets you skip the doing while feeling like you did it.

A junior who prompts an agent into a working feature has knowledge — they can describe what the code does, point at the parts, explain the pattern. What they don’t have is the thing you only get by writing it wrong first: the felt sense of why this boundary and not that one, what breaks when load doubles, which clever line will be a three-hour outage in eighteen months. AI-assisted engineering isn’t faster typing — it’s a different workflow, and the workflow is fundamentally one of review and direction. That’s a senior’s job description. We’ve handed it to people who haven’t yet earned the instincts review depends on.

Debugging is where the gap is starkest. I wrote years ago that debugging is an exercise in thinking, not a tool skill — the work is building an accurate mental model of a system and then finding the one place reality diverges from it. You don’t build that model by skimming generated code and accepting it; passive acceptance teaches nothing. You build it the hard way: from systems you assembled yourself, badly, and then had to understand under pressure because production was down and it was your fault. Take away the building-it-badly and the model has nowhere to come from.

Why juniors get hit first

Seniors are mostly fine. AI hands a staff engineer a draft and they bring fifteen years of priors to bear — they read it the way a structural engineer reads a blueprint, seeing the load paths and the place it’ll crack. The model amplifies judgment they already have. That’s the whole trick, and it’s real. Note the asterisk on “mostly,” though: that judgment is a stock, not a flow — banked under the old curriculum, the one we’re busy automating away. A senior who only reviews and never builds is spending down priors they’ve stopped replacing.

Juniors have nothing to amplify yet, and the tasks that used to build the priors are the ones now evaporating. This is the trap: the same tool that makes a senior modestly more effective makes a junior look dramatically more effective while quietly starving them of the reps that would make the gains real. The output goes up and the learning goes down, at the same time, from the same cause.

The worst failure mode isn’t slow learning. AI is confidently, fluently wrong on a regular basis — an agent deleted a production database in nine seconds and then explained, articulately, why it shouldn’t have. Catching that requires knowing when the plausible thing is the wrong thing, which is exactly the judgment we just established juniors haven’t built. Knowing when to trust an agent and when to step in is the load-bearing skill of 2026, and it’s the one that’s hardest to fake. A junior can’t override what they can’t evaluate. They’ll ship the confident wrong thing, because it looked like all the other confident things that happened to be right.

The lazy move is to cut juniors. It eats your future.

The market’s first instinct is to read all this as “so hire fewer juniors.” It’s the wrong lesson, and an expensive one. AI won’t shrink your team — it’ll expose how much work you were leaving on the table, and the team that handles that surfaced work still needs seniors. Seniors are a renewable resource only if you keep growing them. Cut the junior pipeline and you’ve optimized this year’s burn by quietly canceling 2031’s staff engineers. There is no senior-engineer factory that doesn’t start with juniors; there is only the apprenticeship, and we’re proposing to defund it right as it gets harder to run. And the dodge — let everyone else grow juniors, then poach the finished seniors — only works until enough firms try it that nobody’s growing any, at which point bought-in seniors are scarce and expensive and the ones you grew yourself are cheaper and likelier to stay.

So the question that actually matters isn’t whether to hire juniors. It’s how to grow them now that the curriculum they used to learn from has been automated out from under them.

The field guide: grow architects on purpose

The old model worked by accident — do the grunt work, absorb the lessons. With the grunt work gone, the lessons have to be taught on purpose. That’s the shift: mentoring a junior in 2026 is less “here’s a ticket” and more “here’s how to think like the person who’d architect this.” Four things that actually move it:

Make them build it by hand, once. Before a junior is allowed to generate the auth flow, they write one themselves, slowly, and feel where it’s awkward. You earn the right to the abstraction by having lived without it. This is deliberately inefficient, and the inefficiency is the entire point — it’s the gym, not the commute. Protecting that time is a real fight, because it never looks urgent; making time to learn has always required intent, not slack, and that’s more true now, not less.

Turn the AI into the thing they review, not the thing they trust. The new bug hunt is reading plausible generated code and finding the flaw — the off-by-one in the pagination, the missing transaction boundary, the auth check that’s subtly in the wrong place. Have juniors critique agent output as a daily exercise. It rebuilds, deliberately, the muscle the old debugging afternoons used to build by accident.

Assign systems, not tickets. Hand a junior a whole small service and make them defend the trade-offs — why this boundary, what happens at 10x, where it fails safely. Make them triage an unfamiliar codebase and form a real point of view about it, because reading architecture is a skill you can practice directly instead of waiting years to absorb. The goal is to move them up the abstraction ladder on purpose, faster than the old osmosis ever did.

Grade outcomes, not output. When the cost of producing code goes to zero, the cost of producing the right code — the kind that fails safely and the next person can change without spelunking — is the entire job. Make it a drill: before a junior starts, have them write down what “done” means as outcome conditions, not a diff. It degrades safely under 10x load. The next engineer can change it without you in the room. The failure pages someone with a message they can act on. Then grade against that list, not against whether the code runs. A professional owns the whole outcome — not the diff, the outcome — and owning the outcome is the one thing on this list AI can’t do for them.

The firms that win will manufacture seniors faster

The obvious objection writes itself: if AI just swallowed the bottom of the ladder, won’t the next two model generations swallow the architecture and the judgment too, making this whole project an investment in a skillset with a three-year shelf life? Maybe. But it’s a bet, and the asymmetry runs one way. If understanding stays a human job, the firms that kept growing it win outright. If it doesn’t, everyone loses that layer at once — and the firms that grew real engineers are still best-positioned to work out what comes next, because judgment about a moving target is the last thing to automate. Betting on understanding pays in every world except the one where nothing you did would have mattered anyway.

That gap is a problem, but it’s also a tell: the bottleneck has moved from typing to understanding, and understanding is teachable if you decide to teach it. AI can compress the feedback loop brutally — a junior can now explore ten architectures in the time it used to take to build one, if you point them at understanding the ten instead of just shipping whichever the model produced first.

The companies that lose this decade will read “AI does the junior work” as “so we don’t need juniors.” The ones that win will figure out how to manufacture senior engineers faster than the old apprenticeship ever could — by teaching, on purpose, the judgment that used to be left to chance. The ladder lost its bottom rungs. The firms that bother to rebuild them are the ones that still have a company in five years.