AI didn't break the engineering pipeline. It removed the thing that was quietly building it — and almost nobody noticed.
I wrote recently that "AI replaces engineers" is the wrong frame. For two decades the scarce skill was writing code; AI has made that abundant and created a new scarcity in its place — the judgment to direct AI and catch what it gets wrong. Strong engineers got more valuable. Weak engineering got more expensive. The gap widened.
I still believe that. But a comment on that post stopped me, because it pointed at the part I had glossed over. The danger, it said, isn't this year's productivity story. It's that we stop creating future senior engineers — and that bill comes due in the mid to long term.
That is the right thing to be worried about. And the more I sit with it, the more I think we've misunderstood how seniority was ever produced in the first place.
Judgment was a byproduct, not a curriculum
Nobody is taught senior judgment directly. There is no course. You acquire it the slow way, almost without noticing: by debugging someone else's mess at 2am, by shipping a decision that turns out to be wrong and living with the consequences, by reading thousands of lines of mediocre code until you can smell what's about to break before you can explain why.
The rote work — the boilerplate, the glue code, the unglamorous plumbing — was never just low-value output. It was the gym. It was where pattern recognition got trained, where intuition about systems was earned one painful rep at a time. We treated it as the cost of getting work done. It was actually the mechanism that turned juniors into seniors.
The boilerplate AI now absorbs wasn't just low-value output. It was the gym where judgment got trained.
So when AI absorbs that layer, something subtler happens than "juniors become more productive." The apprenticeship that used to happen by accident — as a side effect of simply doing the work — stops happening by accident. Remove the reps and you don't automatically get someone who skipped straight to wisdom. You risk getting someone who can prompt fluently but has never felt the cost of being wrong.
The expertise paradox
Here is the trap, stated plainly. AI is most useful in the hands of someone with the judgment to direct it and verify it. That judgment was built by doing exactly the work AI now does. If the next generation never does that work, where does their judgment come from?
You can't review what you can't recognize. A senior engineer looks at AI output and feels the wrongness — the subtle race condition, the abstraction that will rot in six months, the "working" code that quietly assumes something that isn't true. That instinct is not magic. It's compressed experience. A junior who has only ever accepted or rejected suggestions, without ever having been forced to produce and defend the reasoning themselves, doesn't develop it. They get faster at generating code and no better at knowing whether it should exist.
This is why the optimistic framing — mine included — needs a correction. "AI replaces weak engineering" is clean and quotable, but "weak" and "junior" get conflated, and that conflation is dangerous. A junior is not a weak senior. They are a senior who hasn't happened yet. If we treat them as the expendable category, we are confusing an unfinished process with a failed one.
The real risk is structural, not individual
Even if every team understood all of this perfectly, the incentives would still pull the wrong way — and that's what makes this hard.
Look at the decision from inside a single team under pressure to ship. Why hire and slowly train a junior, absorbing months of lower output and review overhead, when a senior plus AI ships more today? On its own, that's a reasonable call. It might even be the right one for that quarter. If you need senior capacity today, that is exactly what we provide — senior software engineers from Spain, embedded in your team.
But every team makes the same reasonable call at the same time. Each rational local decision sums to an irrational global one: the industry quietly stops funding the only process that produces the senior engineers AI depends on. The seniors are the scarce input that makes AI valuable, and the market is defunding their supply — while the existing ones keep getting more productive, which masks the shortage for a few years. By the time the gap is obvious in the numbers, you're a decade behind, because you cannot manufacture ten years of judgment on demand.
A junior isn't a weak senior. They're a senior who hasn't happened yet.
It's a textbook tragedy of the commons, and it has a blunt name: eating your seed corn. You can survive a long time burning the supply you were supposed to plant. Right up until you can't.
What actually helps
None of this is an argument against AI, and it's certainly not nostalgia for the days of hand-writing boilerplate. The plumbing was never the point. The point was what doing the plumbing did to you. So the work now is to keep the formative effect while losing the drudgery — and that has to be done deliberately, because it will no longer happen on its own.
A few things I think matter.
Make AI a sparring partner, not an oracle. A junior who asks AI for the answer learns nothing. A junior who is required to interrogate it — why is this wrong, what does it assume, what breaks at scale, what would you do differently — and then has to defend the decision in review can genuinely compress the learning curve. Same tool, opposite outcome. The difference is whether the human is still doing the thinking.
Design the struggle back in on purpose. Productive difficulty used to be free; now it has to be engineered. Give juniors problems where the reasoning is the deliverable, not just the working code. Make them predict failure modes before they run the thing. Have them debug systems they didn't build. The discomfort was doing the teaching all along.
Treat training as infrastructure, not charity. Developing juniors is not a nice-to-have you fund when there's slack. It is how you secure your supply of the one input that's actually scarce. The companies that keep investing through this transition will own the senior talent the rest of the market forgot to grow.
The comment that prompted this was right: the cost of getting this wrong shows up in the mid to long term, which is precisely why it's so easy to ignore now. AI made strong engineers more valuable — that's the logic behind AI-leveraged engineering, and behind the senior people we place. The open question — the one we should be far more anxious about than "will AI replace us" — is whether we'll still know how to make strong engineers in the first place.
Agree, disagree, or living this right now? I'd genuinely like to hear how your team is thinking about it.
FAQ
Does AI replace junior engineers?
No. AI replaces the rote work juniors used to do, not juniors themselves. The real risk is that removing that work also removes the apprenticeship that quietly turned juniors into seniors — so the danger is to the future supply of senior engineers, not to juniors as a category.
Why are senior engineers becoming more scarce?
AI makes existing seniors more productive while teams quietly stop training juniors, because a senior plus AI ships more today than a junior in training. Each team's rational decision sums to an industry that defunds the only process producing new seniors — and ten years of judgment can't be manufactured on demand.
How do you train senior engineers in the age of AI?
Deliberately rebuild the productive struggle AI removed: use AI as a sparring partner juniors must interrogate and defend in review, give them problems where the reasoning is the deliverable rather than just working code, have them debug systems they didn't build, and treat junior development as infrastructure rather than charity.
What is the expertise paradox in AI-assisted engineering?
AI is most useful in the hands of someone whose judgment was built doing exactly the work AI now does. If the next generation never does that work, they can generate code fluently but can't recognize when it's wrong — and you can't review what you can't recognize.