Every few weeks another headline claims AI has wiped out most entry-level programming jobs. Two-thirds gone. Junior developers obsolete. The end of the career ladder.
Most of it is nonsense — inflated numbers and vibes dressed up as analysis. But underneath the noise there is a real signal, and it's more useful (and more actionable) than the doom-posting. I went looking for the data that actually holds up. Here's what it says, and what I think you should do about it.
The number that actually holds up
Skip the job-posting counts — they're misleading, because a "junior" role advertised and then filled by a senior still shows up as a posting. The more reliable measurement comes from payroll data: who's actually employed and getting paid.
In 2025, Stanford's Digital Economy Lab analyzed exactly that, and found something striking. Employment for software developers aged 22–25 fell by nearly 20% from its late-2022 peak. That's real, and it's significant.
But the number that matters most isn't that one. It's the comparison sitting right next to it: over the same period, in the same highly AI-exposed roles, developers aged 30 and older didn't decline at all. Their employment grew.
Junior developers down. Experienced developers up. In the same jobs, at the same time.
What that actually means
Read carefully, because this is where most takes get it wrong in both directions.
It does not mean "AI is killing software engineering." Experienced engineers are doing fine — better than fine. And it doesn't even cleanly mean "AI killed junior jobs," because there are confounds tangled in there: the industry over-hired during the pandemic boom and spent the next few years correcting, and interest rates reshaped hiring too. Anyone selling you a clean "AI did it" story is overselling.
But it does point at something specific and hard to argue with: the pressure is concentrated at the entry point, not across the field. The thing under threat isn't "being a developer." It's "being a junior developer" — the rung where the work is most well-defined, most low-context, and most similar to what AI now does cheaply.
Meanwhile something like 84% of developers now report using AI tools (per the 2025 Stack Overflow survey). The tool that made the bottom rung more crowded is now in nearly everyone's hands. The junior's traditional value — being the fast hands for the well-scoped, low-context task — is exactly what got commoditized.
The uncomfortable, useful conclusion
If the exposed position is "junior" and the protected position is "experienced," then the single most valuable thing you can do for your career right now is stop being interchangeable with what AI does well, as fast as you reasonably can.
Not by working longer hours. Not by memorizing more syntax — the machine has all the syntax. By becoming the thing the machine isn't: someone with judgment, context, and the trust of the people around them. Someone who understands why the code exists, can tell when a plausible-looking answer is wrong, and can be relied on when the problem isn't well-defined.
That, not coincidentally, is roughly the definition of a mid-level developer. Which means the move that protects you in the AI era and the move that advances your career are the same move: get off the bottom rung, deliberately and quickly.
So what do you actually do?
A few things that genuinely move you from "interchangeable" toward "trusted," starting now:
- Stop closing tickets; start owning domains. When you solve something, don't stop at the fix — understand why it worked and how the surrounding system behaves. Depth is what AI can't fake on your behalf.
- Use AI to learn, never to skip the thinking. Ask it why something fails before you let it write the fix. If you can't explain the code you shipped, you didn't level up — you just borrowed an answer you'll be caught not understanding.
- Learn the business, not just the codebase. Understanding why the system exists is what lets you catch a wrong requirement — a judgment call no model makes for you.
- Build trust deliberately. Verify your work before you ship it. Write your decisions down where others can see them. Become the person the team routes problems to.
None of that is a trick, and none of it is fast in the "one weekend" sense. But it's the difference between a developer the market is unsure about and one it's actively protecting.
The bottom rung is more exposed than it's ever been. Let that be the reason you stop standing on it.
I wrote a short book on exactly this — the concrete habits that get a developer from junior to mid, fast, in the AI era. It's called Getting from Junior to Mid, Fast. But honestly, the four bullets above are a real start on their own — no purchase required.
What's your read on the data? Are you seeing this play out on your own team? I'd genuinely like to hear it in the comments.
Getting from Junior to Mid - Fast - in the Age of AI
The junior rung is disappearing under your feet.Payroll data from Stanford's Digital Economy Lab shows employment for developers aged 22–25 fell nearly 20% since late 2022 — while experienced developers in the same AI-exposed roles kept growing. The entry point is under pressure. Experience is the shelter.Which means getting from junior to mid isn't just career ambition anymore. It's the safest move you can make — and this book is about making it fast.This isn't another list of generic advice.No "communicate well" and "take ownership" filler you've read a hundred times. This is a tactical playbook written by a developer who climbed from junior all the way to CTO once — then deliberately started over at a lower rung and is climbing again, on purpose, knowing exactly where each step leads.Every chapter is a concrete habit, a real story, and the view from the other side of the table — what your lead is actually watching for when they decide who gets promoted.What's inside: The one mental model that explains why the junior years feel so hard — and how the developers who climb deliberately shrink it How to actually use AI without quietly sabotaging your own growth — and the one rule that keeps you promotable in the AI era The debugging method that turns panic into a calm, systematic process — the difference reviewers notice from across the room The single highest-leverage writing habit that makes senior developers trust you and your name come up in promotion conversations How to get the title even when no one's going to hand it to you — including the solo-dev case and the exact question to ask a boss who says "not yet" Who it's for:Junior and early-career developers who feel stuck, who are doing mid-level work but stuck with a junior title, or who want to get off the exposed bottom rung before it gets more crowded. If you can already build things but can't tell what's keeping you from the next level — this is the map.Backed by real research, not vibes. Every claim about AI, productivity, and the job market is sourced and honest — including where the popular narrative is overblown.
nikop.gumroad.com
Top comments (1)
The payroll data confirms an economic shift that aggregate job postings hide. The real breakdown is the collapse of the corporate apprentice subsidy.
Historically, hiring a junior developer was a negative net-present-value decision in year one. Engineering organizations willingly absorbed the training friction and lower productivity because well-scoped backlog tasks provided a safe sandbox to build institutional context, with the payoff arriving when that engineer reached mid-level leverage in years two through four.
When language models drop the marginal cost of closing low-context tickets to zero, that training buffer vanishes. Without routine tasks to absorb the learning curve, firms lose the economic mechanism that justified underwriting entry-level payroll. The resulting bottleneck is an industry coordination trap. Every firm wants to hire senior engineers with verified judgment, but no single balance sheet wants to capitalize the cost of training them.