Junior engineers got promoted. Junior engineering got automated.

If you’re an engineer with under five years in — or a career-switcher who just landed the first role, or is still hunting for it — and you’ve watched AI quietly eat the exact tasks you expected to learn the craft on, this is for you. If you’re a staff architect who already makes the calls, or you don’t write code at all, you can skip this one.

Here’s the answer first, because you came for one: the tasks you were going to cut your teeth on — wiring up the boilerplate, translating a clear ticket into working code, fixing the obvious bug — got cheap fast. That part is real and the numbers back it. But the job didn’t disappear. It moved up one rung. The skill that used to take three or four years to reach — deciding what to build, picking the technology, and catching the model when its confident answer is quietly wrong — is now the entry skill, not the reward for surviving the entry years. So the move, if you’re early, isn’t to out-type the machine on the rung that’s vanishing. It’s to practice the judgment one rung up, deliberately, starting now. The rest of this piece is how.

What actually got automated

The thing people call “the junior developer job dying” is more specific than that, and the specifics change what you should do about it.

Routine code generation — the part of the work that turns an already-decided task into syntax — is the part AI does well. In the 2025 Stack Overflow Developer Survey of more than 49,000 developers, 84% now use or plan to use AI tools in their workflow, up from 76% the year before. The boilerplate, the scaffolding, the “I know what this should do, now write it” — that’s the half that got cheap.

And it’s the half junior work was mostly made of. That’s why the hiring data lands so unevenly by age. Stanford’s Digital Economy Lab, using ADP payroll records covering millions of US workers, found that employment for 22-to-25-year-old software developers fell nearly 20% from its late-2022 peak through July 2025 — while workers aged 35–49 in the same occupations grew 6–9% over a comparable window. Same field, opposite direction, split by who does the rote tier. A separate study of 62 million workers found that at companies adopting AI, junior employment dropped 9–10% within six quarters while senior employment barely moved.

So this isn’t “engineering is dying.” It’s “the bottom rung got mechanized, and the people standing on it took the hit.” The work that’s left tilted toward the experienced end. Indeed’s Hiring Lab, tracking live postings, found software-development listings sitting at roughly 64% of their pre-pandemic level in late 2025, with senior titles holding up better than junior ones — employers, among the openings that remain, are asking for more experience, not less.

Here’s the part nobody says out loud: nobody decided juniors were worthless. They decided the tasks juniors used to do are now cheaper to hand to a model. The person was never the point — the rote work was. And once that work is cheap, the only seat left is the one above it.

The pattern is old; the speed is new

This shape has happened before, and the last time it played out, the doom forecast was wrong in an instructive way.

When ATMs spread across US bank branches in the 1970s and 1980s, the obvious prediction was that tellers would vanish — a machine now did the core task, counting and dispensing cash. The routine part did get automated. But tellers didn’t disappear; their job moved up a level — toward the work a machine couldn’t do, like solving a customer’s actual problem and steering them to the right product. The job that survived needed more skill than the one that got automated, not less. (The honest footnote: total teller numbers stayed up partly because deregulation let banks open far more branches — automation alone doesn’t guarantee the headcount holds. The skill-upgrade, though, is the durable lesson.)

Engineering is running the same play. The rote tier — the cash-counting equivalent — gets handed to the machine. The work that’s left is the part that needs judgment: deciding what’s worth building, choosing how, and knowing when the confident-looking output is wrong.

The one thing that’s genuinely different this time is speed. The ATM transition took two decades. This one is compressing into a few years — which is exactly why it feels less like a transition and more like the floor disappearing under the people who just stepped onto it. The pattern is reassuring; the pace is not. That’s the real squeeze on early-career engineers: the rung moved up before they’d had time to climb to it.

Why the rung above is still safe — for now

The natural worry: if the model is climbing this fast, won’t it just take the next rung too? The judgment tier, next?

Not on the current evidence, and the gap is wider than the hype suggests. Two things define the rung that’s still human.

The model is unreliable in exactly the way that matters. The same Stack Overflow survey that found 84% adoption found trust going the opposite way: only 29% of developers say they trust AI output to be accurate, down from 40% a year earlier, and just 3% “highly trust” it. The top day-to-day complaint was answers that are almost right — close enough to look done, wrong enough to cost hours when you ship them. An answer that’s confidently 90%-correct is more dangerous than one that’s obviously broken, because the broken one announces itself.

The model can’t yet own a long, multi-step problem on its own. The research lab METR measures this directly — the length of task an AI agent can finish at even 50% reliability. As of early 2025, that horizon was only a few minutes of expert work, with success dropping below 10% on tasks that take a human more than about four hours. It’s climbing — doubling roughly every seven months — but “doubling from a few minutes” still lands far short of “decide the architecture for a system and carry it through.” The model is a fast, tireless, occasionally-wrong drafter. Someone still has to set the direction, hold the whole problem in their head, and catch the almost-right answer before it ships.

That someone is the job. It used to be the senior job, reached after years on the rung below. Now it’s the entry skill — because the rung below got automated, so there’s nowhere to stand but here.

What to build instead — the judgment skill, on purpose

This is the actionable core. The instinct when AI gets good at coding is to get faster at coding — to compete with the machine on the rung it just took. That’s the wrong rung. The skill to build is the one above: the judgment to direct the model and override it. You can practice it deliberately, even early, and here’s how.

1. Make the call the model only suggests

When the model proposes a library, a database, a pattern — stop and treat it as a suggestion from a confident intern, not an answer. Ask the question it can’t reliably answer for itself: is this the right choice for this system, given what it has to do in a year? Write down why you’d pick it or reject it. Picking technologies and owning that reasoning is a senior skill precisely because it’s a judgment call with no clean right answer — and judgment is the thing the model is worst at and you can get better at fastest.

2. Hunt the almost-right answer

The dangerous output isn’t the one that breaks — it’s the one that runs and is subtly wrong. Make this a habit: assume the model’s confident answer has a flaw, and go find it before you trust it. Read the generated code as if reviewing a stranger’s pull request. Over months, this is the muscle that separates someone who uses AI from someone who supervises it — and supervising it is the rung that’s hiring.

3. Practice the whole arc, not the snippet

The model is strong at the snippet and weak at the long, multi-step problem (that’s the METR finding, applied). So practice the part it’s weak at: take something end to end — define the problem, decide the shape, build it, check it actually solved the real thing. Build a few projects slowly and take each apart to see why it worked, instead of racing through tutorials. Three things understood deeply beats thirty generated and forgotten — because what you’re training is the judgment to hold a whole problem, which is exactly the rung above the automated one.

4. Learn to write the spec, not just the code

Half of senior work is turning a vague want into a clear, buildable definition — deciding what to build before anything gets written. The model can’t do this for you; it needs the clear definition as input. Practice taking a fuzzy idea (“we need users to be able to share this”) and sharpening it into something specific enough that the model’s output can be checked against it. The clearer your spec, the more the model becomes a tool you direct rather than a source you hope is right.

Notice the through-line: every one of these is judgment exercised over the machine’s output — choosing, checking, defining, directing. That’s the rung that didn’t get automated. You don’t reach it by years of paying dues on the rung below anymore, because that rung is gone. You reach it by practicing the judgment directly, now.

The one thing to remember

The junior-developer panic has the story half right and the label wrong. Junior engineering — the rote, decided-task coding — really did get automated, and the early-career hiring numbers show the damage plainly. But junior engineers, as a role in the work, got promoted: the seat that’s left is the judgment seat that used to take years to earn.

You’re not behind. The rung you were aiming for moved up while you were climbing — so aim one rung higher, on purpose, starting with the next thing you build. Direct the model, don’t race it. Catch it when it’s confidently wrong. Decide what’s worth building before you build it. That’s not the reward for surviving the junior years anymore. It’s the job.