The two numbers I want to start with are these. Stack Overflow's monthly question volume fell from 108,563 in November 2022 (the month ChatGPT launched) to 25,566 by December 2024, a 76.5% drop, and by May 2025 monthly question volume had reverted to the level of Stack Overflow's first month in 2009. Brynjolfsson, Chandar and Chen's August 2025 Stanford Digital Economy paper, Canaries in the Coal Mine?, with data through July 2025, found that software-developer employment for the 22-to-25-year-old cohort had declined nearly 20% from its late-2022 peak. The first number describes a knowledge surface used by junior developers as a substitute for the mentors they didn't have. The second number describes the junior developers themselves.
Each number, in isolation, has a defensible reading that doesn't rise to crisis. Stack Overflow's traffic decline was already underway from mid-2021; ChatGPT accelerated rather than caused it. The 22-to-25 employment decline is real but is also entangled with a broader entry-level slowdown across the whole tech sector that has multiple causes. I want to take both numbers seriously without slipping into the apocalyptic register the topic invites, because the pipeline math underneath them is interesting on its own terms and it is the part the apocalyptic framings tend to skip past.
The arithmetic that doesn't move
Software engineers age in a predictable curve. The career stages are well-documented, and they are stages, not a continuum: zero-to-two years is junior; three-to-five is mid-level; six-to-ten is senior; ten-plus is principal or architect. The gates between stages are negotiated, not literal — companies use different titles, the boundaries blur — but the broad shape of the progression is stable across the industry and has been for two decades. The 2030 senior cohort is built primarily from the 2025 junior cohort, with a long tail of bootcamp graduates, lateral hires from adjacent fields, and returners that does not change the overall arithmetic. The 2035 principal cohort is built primarily from the 2025 mid-level cohort by the same mechanism.
That sentence is the load-bearing thing. If the population of juniors hired in any given year shrinks materially, the population of seniors available five-to-ten years later shrinks proportionally. The shortcuts that exist — bootcamp accelerators, intensive apprenticeships, rapid promotions — produce structurally different judgment, and at population scale the substitution capacity is small relative to the cohort gap. The senior is somebody who has spent five-to-ten years making mistakes, getting reviewed, fixing things, debugging at 2am, and gradually accumulating the judgment that distinguishes them from a junior. The time component is largely non-substitutable. There is a body of cognitive-science literature on expertise development — Anders Ericsson's deliberate-practice work is the canonical reference, with subsequent work qualifying the strength of the effect but not the underlying mechanism — that puts numbers on this, but you don't need the literature to recognise the pattern. You just need to look at the org chart of any company that has been operating for thirty years and see who got hired when.
The arithmetic, then, is the arithmetic. SignalFire's State of Tech Talent Report 2025, drawn from LinkedIn data on 600M+ professionals, reports that entry-level hiring at the 15 largest US tech firms fell 25% from 2023 to 2024 and that the share of new graduates in Big Tech hires dropped from 32% in 2019 to 7% in 2024. Entry-level tech postings dropped 60% from 2022 to 2024, by other widely-cited tracking. Google and Meta have been hiring approximately half as many new graduates as they were in 2021. A LeadDev 2025 Engineering Leadership Report found that 54% of respondents expect long-term junior hiring to drop, and 38% agreed that AI tools have already reduced the direct mentoring junior engineers receive from seniors. None of these numbers are adjustable. They are the inputs to the senior-engineer-population calculation for the second half of the 2020s.
What AI is actually doing to junior work
The piece of the story that's specific to AI rather than to the broader entry-level slowdown is what's happening to the kind of work a junior would have done. The 2022-junior's first-year output — boilerplate, unit tests, small features, refactoring of clearly-bounded modules, writing the mid-level-engineer-or-better's draft of a function that the mid-level engineer would then revise — is what a senior engineer with Claude Code or Cursor or Copilot now produces in minutes. The output is closer to what the senior would have asked for. The cost of producing it is a small fraction of what the junior's salary represented. The fundamental engineering economics of training a junior have shifted because the training tasks themselves are no longer differentially profitable to give to a junior.
The second-order finding from a year of operating data is that junior engineers with AI tools are not in fact a competitive substitute for the seniors-with-AI workflow. Mark Russinovich and Scott Hanselman's February 2026 Communications of the ACM piece coined the term AI drag for the phenomenon: early-in-career developers using AI tools have a productivity disadvantage that mid-career developers don't have, because they lack the judgment to steer, verify, and integrate AI output. The 2025 LeadDev survey describes the same mechanism in different words — the 38% of leaders who say AI has reduced the mentoring juniors receive are observing the consequence of the same underlying gap. A junior with Claude Code produces output as fast as a senior with Claude Code, on the surface, but the output requires more rework downstream. The senior's marginal hour with AI is amplified. The junior's marginal hour with AI is the same hour with a lower bug-detection rate and a higher cleanup cost.
This finding is the part that closes the trap. If juniors with AI weren't differentially less effective than seniors with AI, the hiring decision would be a straightforward training-investment question — companies would still hire juniors because they're cheaper to train into seniors than seniors are to recruit laterally. Because juniors with AI are differentially less effective in the short term, the immediate-quarter math favours the senior-only team, and the immediate-quarter math is what budget cycles run on. The pipeline-math half of the equation operates on five-to-ten-year horizons that no quarterly review surfaces.
Where seniors come from when juniors aren't being trained
If you walk forward the arithmetic by half a decade, you reach a position the industry has not yet articulated honestly. 2030 senior-engineer demand is bounded above by 2025 junior-engineer hiring. The companies whose 2025 hiring decisions trimmed juniors will have proportionally fewer mid-level engineers in 2028 and proportionally fewer senior engineers in 2031. The natural response of a company finding itself short of senior engineers in 2031 is to recruit them laterally — but the population available to recruit from is the same population every other company in the same situation will be trying to recruit from, and the labour-market clearing price for a 2031 senior engineer will reflect that scarcity.
Companies that have hired juniors continuously through 2024–2026 will, in 2031, find themselves with a senior-engineer cohort their competitors cannot easily match. Companies that paused junior hiring during this window will face one of three options in 2031: pay the elevated lateral-hire premium for senior engineers; train mid-career hires (developers from outside the field, bootcamp graduates, returners) into seniors on a compressed timeline that almost certainly produces lower-quality outcomes; or scope down the work to what their existing senior population can do. None of these options is bad on its own. The combination of all three across an industry that historically grew its senior pool through internal training has the predictable shape that economics has documented in any market where a single producer cohort tries to skip a generation of replacement workers — the producer-cohort price rises, the supply tightens, and the most-dependent buyers find themselves under contractual leverage they have not previously had to negotiate.
The most uncomfortable version of this is the eval(code) framing: if you stop hiring juniors, your seniors own you. The framing is more glib than the underlying point deserves, but the underlying point survives. A senior-only engineering organisation is a labour-market position with a known direction.
What kinds of work still build judgment
The technical question that follows is what an AI-era training path for junior engineers actually looks like. The conventional path — boilerplate-and-bugs producing pattern-recognition and judgment over five years — is the path AI tools have most thoroughly automated. The proposals on the table for what replaces it cluster around three patterns:
Read-and-explain work. A junior who can take an unfamiliar codebase and produce a coherent explanation of what it does, where the failure modes are, and where the architectural decisions don't fit the current requirements, is doing the kind of work that builds the judgment a senior engineer needs. AI tools can produce a first-pass explanation faster than the junior can; they cannot produce the judgment about which parts of the explanation to trust that the junior is being trained to develop. The exercise of producing the explanation, comparing it to AI-generated explanations, finding the discrepancies, and explaining the discrepancies is one shape of training that survives.
Verification-and-audit work. The output of an LLM is most usefully treated as a draft that requires verification. Juniors who specialise in verifying AI output — running the test cases, checking the citations, finding the cases the LLM didn't cover — are doing work that is structurally similar to code review and produces similar judgment. The preceptorship model that Russinovich and Hanselman propose in their Communications of the ACM piece is one shape this can take: a junior paired closely with a senior, with the junior's day-to-day work organised around auditing, prompting, and verifying AI output as a core competency from the first week rather than as a senior-only meta-skill picked up later.
Real-system work. The category of work that AI tools are worst at is the work that requires understanding which abstractions the team has chosen and why. Codebases ten years old are full of decisions that look strange in isolation and make sense only in the context of the operational history that produced them. A junior tasked with maintaining a long-running system, fixing the incidents, learning why the previous abstractions are there, builds judgment that doesn't emerge from greenfield AI-assisted code generation. The work survives because the codebase predates the AI tools and the AI tools cannot reconstruct the operational history.
What these patterns share is that the training component is structurally separated from the production component. The production work the junior does is no longer differentially valuable on the immediate-quarter timeline; the training work is differentially valuable on the five-to-ten-year timeline. Companies that take the pipeline-math seriously are the ones that will fund the training work as a first-class deliverable rather than as a byproduct of production work that AI tools have made redundant.
The summary that matches the data
| Stage | Years of experience | 2025 cohort observed | Implication for 2030 |
|---|---|---|---|
| Junior | 0–2 | SignalFire: hiring at top 15 US firms down 25% YoY 2023→2024; new-grad share of Big Tech hires 32% (2019) → 7% (2024); entry-level postings down 60% 2022→2024; 22–25-year-old developer employment –20% from 2022 peak (Stanford, July 2025 data) | Smaller pool of mid-level engineers in 2028 |
| Mid-level | 3–5 | Filled by 2020–2022 junior hires (the last full cohort) | Smaller pool of senior engineers in 2031 |
| Senior | 6–10 | Filled by 2015–2019 junior hires (full cohorts; the largest available pool the industry has ever had) | Lateral-hire premium rises sharply 2030–2033; senior-only orgs face contractual leverage |
| Principal | 10+ | Filled by 2015–2019 mid-level hires, several promoting up; the top of the pyramid is currently flush | The supply of principal-level engineers in 2035 depends on the 2025 mid-level cohort, which depends on the 2020–2022 junior cohort; this is the last point at which the math is fully baked |
The table is a description, not a forecast. Each row's 2025 cohort observed column is reported data from the cited sources. Each row's Implication for 2030 column is the mechanical consequence of the time arithmetic. The forecast component lives in the gap between the two — the assumption that hiring patterns from 2024–2026 will continue, that AI tools will not change in ways that re-open the junior-training path, that companies will not collectively course-correct in time. These are real assumptions, and reasonable people will disagree about each one. The arithmetic does not require the assumptions to be correct in detail; it requires only that the gap between the cohort sizes does not get retroactively filled.
What this is not, and what it is
The honest answer to should I learn to code in 2026 splits along an axis the discourse has tended to flatten. Coding as a career — the path from bootcamp through three years of junior work to a mid-level role at a name-brand firm — is structurally narrower than it was. Coding as a general-purpose intellectual skill — reading what an AI assistant produces, verifying its output, automating the small things that bother you — is more useful than ever, partly because the AI tools are most useful to people who can read what they produce.
Should you spend three years on a CS degree to enter the entry-level dev market in 2027? The market looks very different from your older sibling's. Should you learn to code well enough to read what an AI assistant produces? That one has a much clearer affirmative answer, and the people who can do it are well-positioned for the kind of work the pipeline math is not eliminating.
The pipeline crisis is real on the timeline the data describes. The career advice is more local; the local answer depends on which side of the pipeline the reader is positioned on. Both can be true.
Top comments (1)
Hello,
I am glad to see your post
This is a deeply thoughtful and data-driven analysis of a shift that is often discussed in overly simplistic terms.
The way you connect Stack Overflow usage trends with junior hiring data creates a strong empirical foundation for the argument, rather than relying on speculation.
I especially appreciated the framing of software careers as a time dependent pipeline problem, where today’s hiring decisions directly shape senior and principal capacity years later.
The discussion around AI’s impact on junior work is particularly compelling, especially the idea that productivity gains are uneven and depend heavily on existing judgment.
The distinction between “production work” and “training work” is one of the most important insights in the entire piece.
Overall, this is a rigorous and sobering look at how structural changes in tooling may reshape the long-term talent ecosystem.
I wish your next post is the best post more than before
From Aljen M