The junior pipeline broke and nobody owns fixing it

Entry-level developer postings have fallen roughly 40 percent. The usual reading is that AI replaced junior work, which is close enough to true to be misleading, and it obscures the part that should worry you: nobody has replaced the mechanism by which juniors became seniors.

Every organisation currently benefits from a stock of experienced engineers trained by a system that has stopped running. That is a collective action problem, and collective action problems do not solve themselves.

What the apprenticeship actually was

The path was never a curriculum. It was an accident of economics.

Simple work existed and had to be done by somebody. It was cheap to hand to a beginner because the blast radius was small and the review was quick. Doing it repeatedly, under correction, taught the thing that cannot be taught directly: a feel for how systems fail. Write forty CRUD endpoints and you develop instincts about validation, error handling and where things go wrong that no amount of reading produces.

That work was the training environment, and it was free because it was work that needed doing anyway.

It is now the work that automates most completely. Not partially. The boilerplate, the simple endpoint, the unit tests around an existing function, the straightforward bug fix in a well-tested area. All of it.

What juniors learned on

• Boilerplate and scaffolding
• Simple endpoints, well-bounded
• Unit tests for existing code
• Straightforward bugs in tested areas
• Small, reviewable, low blast radius

What is left for them

• Reviewing output they cannot yet judge
• Work with real blast radius, too early
• Nothing in between

The trap in the middle column

There is a fashionable answer: juniors now review and orchestrate rather than write, which is more valuable work, so this is an upgrade.

I think this is exactly backwards, and it is worth being blunt because it is being repeated confidently.

Reviewing requires the judgement that writing produces. A junior asked to assess whether generated code is correct is being asked to exercise the skill that the removed work was supposed to build. They will accept plausible output, because plausible output is indistinguishable from correct output to someone who has not yet been burned by the difference. That is not a failure of diligence, it is the absence of a prior they have had no opportunity to form.

So a junior who accepts what they do not understand creates debt at machine speed. That framing is common, and it is usually delivered as a warning about hiring standards. It should be read as a description of what happens when you put someone in a role their training has not prepared them for.

Why nobody fixes it

The economics are brutally clear at the level of a single company.

Training a junior costs roughly a senior’s week per hire in supervision, plus a year before net contribution. Under the old model you paid it because you got cheap execution capacity on work that had to happen anyway. That offset is gone. So the calculation is now: pay a year of cost, or hire someone another company trained.

Every firm reaches the same conclusion. It is individually rational and collectively catastrophic, on a delay of about five years, which is longer than most planning horizons and considerably longer than most tenures.

NowEntry-level postings down ~40%. Existing seniors absorb the work. Nothing visibly wrong.

Two yearsThe mid-level band thins. Hiring for it gets competitive and expensive.

Five yearsSenior hiring is a bidding war over a cohort that was never trained.

The responseFirms that kept training have the only supply, and will not be selling it.

The counter-signal worth watching

Not everyone is doing this. Some large enterprises increased junior hiring in 2026 while startups cut it, which is the opposite of the usual pattern and worth understanding.

The plausible reason is time horizon. An organisation that expects to exist in ten years and needs a hundred senior engineers then has a reason to train now that a company optimising for the next funding round does not. If that reading is right, the training capacity of the industry is consolidating into firms with long horizons, and the labour market implication is unpleasant for everyone else.

What a fix looks like, if anyone wants one

The rungs have to be rebuilt deliberately, because they no longer appear as a side effect.

Juniors need to write things that matter, in bounded areas, with real review. Not simulated tasks, which nobody takes seriously, and not orchestration, which needs judgement they lack. Actual features in a well-tested subsystem where the cost of a mistake is bounded and a senior will read every line.

And they need to debug. Debugging is a search process under uncertainty and it is the most transferable skill in engineering. It cannot be automated away from a learner because the learning is the search, not the answer.

Where this breaks down

I have not shown the seniors of the future must come from this pipeline. People switch fields, teach themselves, arrive from adjacent disciplines. The pipeline I am describing was one route among several, and I have treated it as though it were the only one.

“Bounded work with real review” costs review capacity you do not have. This series has argued repeatedly that review is the constraint. Training juniors consumes exactly that resource, which means the fix competes directly with delivery, and I am not going to pretend that resolves cleanly.

The 40% figure is a market snapshot, not a structural finding. Postings fall in downturns for ordinary reasons. Some of this is macro rather than AI, and anyone attributing all of it to agents is overreaching.

And juniors may genuinely learn differently now. Someone who has worked with agents from day one may build judgement through a route I cannot see, because I did not learn that way and I am reasoning from my own path. That is a real limit on this argument.

The takeaway

The junior pipeline was an economic accident, not a programme, and the accident stopped happening. The work that trained people is the work that automated, and reviewing agent output is not a substitute because it requires the judgement the removed work created.

No single company has an incentive to fix this, the damage lands about five years out, and firms with long time horizons appear to be quietly taking the other side of the trade.

If you take one thing into next week: ask how many engineers your organisation has trained from zero to senior in the last three years. If the number is zero, you are relying on someone else’s pipeline, and you should know whose.