What is actually cutting the junior pipeline

A delivery-system read on the labour-market evidence, and the lever you actually hold.

If you've spent any time on LinkedIn in the last six weeks, you've seen the argument. Junior software engineering jobs are disappearing. AI is eating the entry-level rung of the ladder. The cohort that should be learning to code right now is being skipped, and in three years there will be a hole in the senior tier nobody is preparing for.

The argument has weight because there is now real evidence behind it. Not vendor surveys, not LinkedIn anecdotes. Large-N administrative payroll data. But the version most people are quoting from that evidence is the wrong one. The interesting finding isn't that young workers in AI-exposed jobs are losing ground. It is which AI-exposed jobs are losing ground, and which ones aren't.

That distinction sits inside a variable a Delivery Manager controls.

What the strongest evidence actually says

Brynjolfsson, Chandar and Chen at Stanford Digital Economy Lab pulled monthly payroll records from ADP (the largest payroll processor in the US, with over 25 million workers in panel) through September 2025. They cross-linked occupational AI exposure to age-cohort employment changes. The headline finding, after controlling for firm-level shocks: workers aged 22 to 25 in the most AI-exposed occupations show a roughly 13 to 16% relative decline in employment since late 2022. Older workers in the same occupations are stable or growing. Wages haven't moved meaningfully. The adjustment is happening through hiring, not through compensation.

That's the headline. It is the part LinkedIn is quoting.

The part LinkedIn isn't quoting is fact number three from the same paper. The declines are concentrated in occupations where AI primarily automates tasks. Occupations where AI use is primarily augmentative (task iteration, learning, validation) show employment growth, including for young workers. The fifth quintile of augmentation, the most augmentative occupations, is one of the fastest-growing parts of the young-worker labour market.

Two things happen with generative AI in delivery work. Sometimes it replaces a person doing a task. Sometimes it sits next to a person doing a task. The first one cuts juniors. The second one hires them.

This isn't only a US-payroll finding. Daniotti and colleagues, writing in Science, classified AI-generated Python in over 30 million GitHub commits across roughly 160,000 developers. About 29% of US Python functions are now AI-written. The technology has lifted overall code contributions by about 3.6%. But the productivity gain is captured almost entirely by senior developers. Early-career developers are the heaviest users of generative AI tools and show no measurable productivity benefit.

If you only had Stanford and Science, the read would be straightforward: AI is eating juniors, and even the juniors using AI heavily aren't getting faster.

Then you read Baird, Carpanelli, Xu and Xu in Contemporary Economic Policy. They linked LinkedIn profile data to firm-level GitHub Copilot corporate licences. Firms that adopt Copilot show a 3 to 5% higher monthly probability of hiring software engineers, and the effect is driven by entry-level hires. New hires bring about 5% more non-programming skills with no decrease in coding skills.

So which is it? Is AI cutting juniors or hiring more of them?

The reconciliation is the deployment-mode variable. Copilot, as deployed by most firms in the Baird sample, is an inherently augmentative tool. It sits in the IDE next to the developer and suggests. The human approves every keystroke. Copilot-adopting firms land in the augmentation panel of the Stanford figure. Their hiring goes up, and their junior hiring goes up most. The Stanford paper and the Baird paper aren't telling different stories about the technology. They are telling the same story about two different deployment choices.

Xu, Hou, Chen and Xie laid this out theoretically in a 2025 working paper. Their 2x2 model splits GenAI deployment along two axes: mode (automation versus augmentation) and location (worker layer versus expert layer). Their reading is that the decline in junior employment documented in recent studies reflects deployment choices favouring automation over augmentation, not an inevitable consequence of GenAI itself.

That sentence is the article.

Why this is a delivery problem, not a procurement problem

Procurement decides what tool gets bought. Delivery decides what deployment mode that tool ends up running in.

A team that pipes Copilot suggestions into a developer's IDE, where a human writes every commit, has bought an augmentation-mode deployment. A team that runs an autonomous agent that opens PRs against the main repo with senior review at merge time has bought an automation-mode deployment of the same family of technology, or close to it. Same vendor catalogue, different deployment, different effect on the apprentice margin.

The lever lives in choices most teams treat as plumbing:

• PR routing for agent-generated work
• Review-policy thresholds for agent versus human PRs
• Ticket assignment rules in Jira or ADO
• Story shaping for work that AI is expected to handle
• Pairing patterns for first-90-day hires
• Sandbox and staging access for new joiners

Each of these decisions is a deployment-mode declaration the team is making, often without naming it. Each one nudges the system toward the AI does this work or the AI helps the human do this work.

The Brynjolfsson paper offers a useful mechanism here. AI substitutes most easily for codified knowledge: the textbook content, the specifiable, the checkable. It substitutes much less easily for tacit knowledge: the idiosyncratic, the institutional, the never-quite-written-down. Junior engineers supply mostly codified knowledge to a team. That used to be valuable. In an automation-mode deployment, that's the exact tier the AI is eating.

What used to be the bottom of your backlog (small, specifiable, tractable) was the work juniors did to build judgement. If you have routed that tier to AI, the juniors haven't been replaced. They've been bypassed at the entry point of the capability ladder. Three years from now, your senior pipeline will be a slightly different problem.

What an honest read of your own org looks like

You can pull a useful first cut in a week. Five questions, baseline data, nothing fancy.

1. Where is AI doing directive work, and where is it doing iteration work? Pick a representative team. Look at the last 30 days of actual AI use. Categorise into the AI did the task versus the AI helped the human do the task. The split tells you which quintile you're in.

2. What did your last 10 junior hires actually do in their first 90 days? If the answer involves reviewing agent PRs and chasing AI-generated boilerplate, you've moved them up the value chain before they had the tacit knowledge to judge what good looks like. They will not stay long, and they will not turn into your seniors. If the answer is paired delivery on bounded work, with safe failures and senior availability, the apprentice margin is still intact.

3. What happened to the bottom 20% of your backlog over the last quarter? The small, specifiable items. Track where they went. Self-served by AI agents? Bundled into larger AI-assisted stories? Disappeared because nobody saw them as worth tracking? That tier used to be the throughput juniors were judged on. If it's gone from view, so is the visibility you need to grow the next senior.

4. What does your PR routing look like for agent-generated work? This is the operational tell. If agent PRs flow into the same review queue as a junior's first PR, you are augmentation-mode. The agent is a teammate, not a replacement. If agent PRs route to a separate, senior-only review queue with the implicit message that this is finished work that just needs sign-off, you are automation-mode. The juniors are not in the loop.

5. Are you measuring anything at the apprentice margin? Time-to-confident-merge for first-90-day hires. Debug-time on junior-owned incidents. Review-comment depth on unfamiliar code. If you have none of these, you cannot see the apprentice margin at all, and the automation-mode decision will happen by default because no signal is pulling against it.

None of these are exotic. They are the kind of read a Delivery Manager pulling Jira or ADO data does every Monday morning. The trick is to pull them with the deployment-mode question in mind, not the productivity question. They are different questions.

What the evidence does not yet say

Three caveats worth holding while reading any current claim about juniors and AI.

The Stanford ADP paper is a working paper. Peer review is still pending. Replication is in progress. The mechanism, deployment mode determining the apprentice-margin effect, has theoretical support from Xu and empirical support from both Brynjolfsson and Baird, so the broad shape of the story is solid. The specific numbers are not yet locked in.

All four primary papers cited here are US data. The DACH labour market behaves differently. Slower hiring and firing margins, stronger works-council involvement, a real apprenticeship tradition for some technical roles. The mechanism should transfer. The specific size of the effect should not be quoted at a DACH client.

Baird et al. measured Copilot specifically. Autonomous agent platforms (Cursor Agent, Devin, Replit Agent, internal orchestration tooling) are closer to automation-mode by default. A finding of Copilot adoption hires more juniors doesn't generalise cleanly to agent-platform adoption hires more juniors.

And there's a deeper limit. The evidence is about the last three years. The technology is moving faster than the panel. What looks like a stable augmentation/automation distinction today may collapse the moment IDE assistants start running multi-step autonomous flows. The article that finally measures that is not yet written.

The Monday-morning question

If you run delivery, the question you can answer this week is small and specific. Not will AI take my juniors' jobs. That is a question for an essayist. The question for you is this: when I look at the last 30 days of AI use in my team, am I running augmentation-mode or automation-mode? What is the evidence, in PR routing, in ticket assignment, in how first-90-day hires are spending their time, for which mode I'm actually in?

You don't need a manifesto on the future of work to answer that. You need ten minutes with the right four queries and a willingness to call what you see.

The labour-market data isn't telling you the apprentice margin is gone. It's telling you the apprentice margin is now sensitive to a deployment choice your team has probably already made by accident. Naming the choice is the first useful thing.

Sources

• Baird, M., Carpanelli, M., Xu, B., & Xu, K. (2026). Firms' GitHub Copilot adoption and labor market outcomes for software engineers. Contemporary Economic Policy. Advance online publication. doi.org/10.1111/coep.70035
• Brynjolfsson, E., Chandar, B., & Chen, R. (2025). Canaries in the coal mine? Six facts about the recent employment effects of artificial intelligence [Working paper]. Stanford Digital Economy Lab. digitaleconomy.stanford.edu
• Daniotti, S., Wachs, J., Feng, X., & Neffke, F. (2026). Who is using AI to code? Global diffusion and impact of generative AI. Science, 391(6787), 831–835. doi.org/10.1126/science.adz9311
• del Rio-Chanona, R. M., Ernst, E., Merola, R., Samaan, D., & Teutloff, O. (2025). AI and jobs. A review of theory, estimates, and evidence [Preprint]. arXiv. arxiv.org/abs/2509.15265
• Mayer, A.-S., Baygi, R. M., & Buwalda, R. (2025). Generation AI: Job crafting by entry-level professionals in the age of generative AI. Business & Information Systems Engineering, 67(5), 595–613. doi.org/10.1007/s12599-025-00959-x
• Xu, F., Hou, J., Chen, W., & Xie, K. (2025). Generative AI and organizational structure in the knowledge economy [Preprint]. arXiv. arxiv.org/abs/2506.00532