Who will train your seniors: the bench AI is emptying

There is a decision passing almost unnoticed in Italian small and mid-sized companies in recent months, often taken in ten minutes over the payroll budget, and it will show its effects three years from now: not opening the junior position. It is not a cut, it appears in no announcement, it makes no news. It is simply a box left empty this year, for a reason that sounds sensible: we have AI now.

The American data says this is genuinely happening, at scale. The question almost nobody is asking is who will train the seniors you will need in 2029.

Junior developers: not laid off, not hired

The study with the best data on this is Canaries in the Coal Mine? by Erik Brynjolfsson, Bharat Chandar and Ruyu Chen, from the Stanford Digital Economy Lab, in its August 2026 revision using ADP payroll data through June 2026. These are administrative records of wages actually paid to millions of US workers, not an opinion survey. Worth keeping in mind, because no equivalent measure exists for Italy.

The central finding is this: in the United States, employment of workers aged 22 to 25 in the occupations most exposed to AI sits 19% below that of peers in less exposed occupations. Experienced workers show no comparable gap, and the divergence has widened month after month since August 2025.

But the finding that matters for whoever decides is a different one, and headlines tend to skip it. Nobody is sending juniors home: companies have simply stopped taking them on. The decline runs through hiring that never happens, not layoffs, and that difference is substantial, because a layoff is a visible event somebody has to justify, while a position never opened leaves no trace anywhere.

In Italy the problem shows up the other way around

Here the picture gets more complicated, and in the least comfortable direction. While other markets debate young developers who cannot find a first job, Italian companies have spent years reporting they cannot find exactly those profiles.

In Unioncamere's January 2026 Excelsior bulletin, application design analysts and specialists were the hardest profile to recruit among all intellectual and scientific roles: hard to recruit in 62.7% of cases, against a 45.8% average across all occupations. Nearly seventeen points above.

One caveat on that number, because it matters: the survey ran between 18 November and 4 December 2025 across roughly 96,000 companies, so it is a snapshot of late 2025, not of today. Average national difficulty has fallen since: the Excelsior release of 10 July 2026 puts it at 42.6% of open positions. The profession-by-profession detail for mid-2026 is not public, so I cannot say whether the 62.7% fell in proportion. I know that the general picture has eased and that software profiles started well above average.

What the figure measures matters too. Excelsior records the difficulty declared by companies, splitting it between lack of candidates and preparation judged inadequate, so it counts how many people turn up on the terms offered. Put another way: part of the difficulty is a variable set by whoever is hiring.

The paradox holds either way: companies are no longer training the people they already cannot hire.

What breaks is not the code

The argument against junior hiring is that AI writes the code the junior used to write. Taken literally that is even true, and that is exactly where the analysis stops too early: it assumes that person's value was the code.

It was not. A junior who spends three years in a company produces code as a by-product; what they actually accumulate is knowledge of how your quoting process works, why that field in the ERP cannot be touched, which customer calls when stock counts drift. On more than one engagement with manufacturing ERPs I have found the same scene: the rule nobody was allowed to touch was written down nowhere, and the only person who knew why it existed had joined the company ten years earlier as a junior. It is the same thing that makes body rental, the consultant hired out by the hour, expensive: a capable person who does not know the domain takes months to become useful, and the client pays for those months twice.

The path that turned that person into a senior ran through friction AI now removes: reading someone else's code and not understanding it, breaking something in production, having a pull request rejected and finding out why. Removing friction speeds up delivery and slows down the formation of judgment, and the second effect stays invisible until you need it. That is cognitive debt: like technical debt, it accrues quietly and is repaid with interest.

Is it still worth hiring a junior, if you have AI?

The strongest objection to what I have written so far is not that juniors are finished: it is the opposite, that companies not hiring them are solving the wrong problem. The argument is that with AI a junior becomes productive sooner, because the mechanical part of learning (a new syntax, an unfamiliar tool) no longer consumes a senior's time, which stays free for the part that counts.

And it is consistent with the fifth finding in the Stanford study, the one rarely quoted: declines concentrate in occupations where AI substitutes for human tasks, while where it complements them employment is flat or rising. The effect therefore follows from how each company decides to use the tool, and it lands differently depending on that choice.

Which is the real point. If you use AI to replace new people entering your company, you are buying the gap. If you use it to shorten the time a new person needs to become autonomous in your domain, you are running the opposite operation with the same tool.

There is a more concrete objection, though, and it is the one I actually hear: they leave after two years and I have trained a competitor. It happens, and it happens more often to companies with nothing to offer after the first year. You do not lose a junior when a better offer arrives, you lose them when they stop learning something they could not learn elsewhere. If your domain is complicated, that is your advantage, not your problem.

The cost remains, and it belongs on the table. The ordinary vehicle for a first hire in Italy is the apprendistato professionalizzante (article 44 of legislative decree 81/2015): ages 18 to 29, up to three years, and for employers with up to nine employees the company's contribution rate drops by 8.5 points in year one and 7 points in year two, meaning 1.5% and 3% against the ordinary 10% (INPS circular 108/2018). The real comparison, then, runs between a junior on an apprenticeship and the days of an external consultant at the same cost.

Three concrete things, if headcount is your call

Count how many people know your critical processes. Not how many can program: how many could rebuild the order flow if it collapsed tomorrow. Do it for real: take the three processes that would stop your company and, for each, write down who would get it running again without calling anyone. It is a half-hour exercise and the result usually surprises whoever runs it. If the answer is one or two, that junior position is worth as much as continuity insurance.

Change what you ask of new arrivals. Do not stop having them write code: keep letting them break things, in environments where breaking is cheap. But add the work AI does not do and that nobody used to hand a junior: reviewing generated code and saying why it is wrong, explaining whether an architectural choice holds, talking to whoever will use the feature. That is exactly what builds a senior. And account for the part nobody budgets for: in the first months the real cost is the senior's hours, far more than the salary. If those hours do not exist, the junior position is not really open, it is only open on paper.

Treat domain knowledge as something to write down, not to remember. If it stays verbal, it leaves with whoever holds it. That is why the Forward Deployed Engineer model puts whoever builds inside the client's process: what they learn ends up written into the system rather than in someone's head. And the right person may already be inside: someone who knows the process and cannot program has already solved the hard half of the problem. Training the people already there and hiring the ones who come in are not alternatives, they are two ends of the same bench.

In short

In the United States, hiring of young developers really has stopped, but through positions never opened rather than layoffs, which makes the phenomenon nearly invisible while it happens. Italy does not measure it the same way, but it lands on top of a declared shortage in exactly those profiles. Skipping a junior hire today is not a saving: it empties the bench, and the bill arrives when you need that senior and the market charges you for what they have become: rare.