Entry-Level Developer Jobs Dropped 20%. Senior Roles Didn't Move.
The chart doesn't look like a slope. It looks like a cliff on one side and a flat line on the other. Software developers aged 22 to 25 — the entry-level cohort, the ones who just finished a bootcamp or a CS degree and were supposed to be starting a career — saw employment fall nearly 20% from its late-2022 peak through July 2025. Developers aged 41 to 49, doing ostensibly the same job at the same companies, saw no meaningful change at all. Same industry, same tools, same AI rollout. One group got quietly erased from the hiring pipeline. The other didn't notice.
That split is the actual story, and it's more specific and more damning than the version everyone's already arguing about online. This isn't "AI is coming for developer jobs" in the abstract. It's a study showing AI came for exactly one developer job — the first one — while leaving every job after it untouched.
The study everyone's citing wrong
In November 2025, Stanford's Digital Economy Lab published "Canaries in the Coal Mine? Six Facts about the Recent Employment Effects of Artificial Intelligence," authored by Erik Brynjolfsson, Bharat Chandar, and Ruyu Chen, built on ADP payroll records covering tens of thousands of firms across roughly eleven quarters, from October 2022 through July 2025. Their finding, stated plainly in the paper: employment for 22-to-25-year-old software developers declined nearly 20% from its peak in late 2022 by July 2025, while employment for developers aged 41 to 49 showed no meaningful change over the same window.
Two things matter about how that finding gets used in practice, and both get flattened in the retelling. First, this is occupation-specific — the steepest declines showed up concentrated in software development and customer service, the two categories with the most AI-automatable routine output, not spread evenly across the labor market. Second, there's a second, frequently conflated dataset in circulation — a separate Harvard analysis using Revelio Labs résumé data, covering a different sample size and a six-quarter window — that gets mashed together with the Stanford numbers in a lot of casual coverage. They're independent studies using different methodology, and citing them as if they're one paper misrepresents both. The Stanford ADP data is the cleaner, more directly employment-verified source, and its number is unambiguous: senior developers flat to growing, junior developers down by a fifth.
Why the AI took the entry rung specifically
The instinctive explanation — "AI writes code now, so junior devs are redundant" — doesn't actually survive contact with what junior developers were hired to do in the first place. Junior engineers were rarely hired because their code output, dollar for dollar, beat a senior engineer's. They were hired because someone has to write the unglamorous first-draft code, the boilerplate, the test scaffolding, the small well-specified tickets — the teachable tier of work that, historically, doubled as on-the-job training for the next decade of that person's career. AI coding tools are extremely good at exactly that tier: bounded, well-specified, low-ambiguity tasks with clear acceptance criteria. That's not a coincidence. It's the precise overlap between "what AI does well" and "what used to be a junior developer's entire job description."
Senior developers, by contrast, spend their time on the parts of the job current AI tools still handle badly — architectural tradeoffs across systems nobody fully documented, judgment calls about what not to build, debugging failures that span three services and a vendor API, translating a confused stakeholder's request into an actual spec. None of that shows up as a task AI can quietly absorb, which is exactly why the 41-to-49 cohort's employment line stayed flat while the 22-to-25 line fell off a cliff. The tools didn't get better at being senior engineers. They got good enough at being junior ones, which turned out to be sufficient.
The bill nobody's line item shows
Here's the part the earnings calls won't mention, because it doesn't show up for another five to eight years: the entry-level tier wasn't just a job category. It was the feeder system that turned into the senior tier. A company that stops hiring junior developers today isn't saving headcount cost in some neutral, victimless way — it's quietly deciding it won't need internally-grown senior engineers in 2032, because the people who would have become them were never given the entry rung to start climbing. This connects to a problem I've written about before with AI code review — that AI-assisted review, done carelessly, can strip out the exact feedback loop that used to turn junior engineers into senior ones. The Stanford data is the employment-side confirmation of the same mechanism: the scaffold isn't being maintained poorly. In a lot of companies, it's simply not being built at all.
The organizations optimizing hardest for this quarter's velocity metrics are the ones most likely to discover, in half a decade, that they have plenty of senior engineers on staff and almost no plausible path to replacing them when those engineers eventually leave, retire, or get poached — because the pipeline that used to manufacture senior engineers from junior ones got quietly switched off sometime around 2023, and nobody put "we are no longer training our own replacements" on any dashboard anyone was watching.
What actually changes if you take this seriously
The fix isn't "hire junior developers anyway out of nostalgia for how things used to work" — that's not a business case, it's a plea. The fix is recognizing that the entry-level role needs to be redesigned around what AI can't absorb: pairing junior engineers with senior ones on the judgment-heavy, ambiguous, cross-system work AI still handles poorly, instead of on the bounded tickets AI now does instead. That's more expensive per junior hire in the short term, because it requires senior time that used to go straight into shipping. It's also the only version of "junior developer" that survives the next five years of tooling, because it's built around the actual, durable comparative advantage humans still hold — not the shrinking sliver of work that happened to be bounded enough for a model to absorb first.
The chart with the cliff on one side isn't a prediction. It's already the employment record for the last three years. The only open question is whether anyone currently hiring is looking at the flat line on the other side of that chart and asking where it's going to come from in 2033, or just quietly enjoying how much cheaper this quarter got.