A pyramid with a wide junior base on the left, an arrow pointing right to a diamond with a thin neck where the base used to be

Two conversations from earlier this year keep coming back to me. One was with an engineering manager I used to work with, talking about a pipeline of work that was thinning out. Not “the project got cancelled” thin. The kind of thin where you look six months out and start wondering what people will be doing. The work was leaving, and nothing was coming back to fill it. The team was strong, the manager was strong, and the worry was about the juniors.

The other one was on the business side. Someone outside engineering was using Claude Code to automate a workflow that used to need an engineer, and getting good at it pretty fast.

Two unrelated signals, same week. The work juniors used to grow on is being eaten from two sides at once, and almost nobody is talking about where the next generation of senior engineers comes from.

The Pyramid Trained People by Accident

The old shape of a software org was a pyramid. A few seniors at the top, a wider band of mids, a wide base of juniors. The base did the tedious work, fixing bugs, writing tests, reading unfamiliar code, refactoring, chasing down why staging is broken at 2pm on a Tuesday.

Nobody designed that base to be a training program. It just happened to be one. The tedium was the gym. You can’t read fifty thousand lines of someone else’s code and not come out the other side with taste. Debugging a flaky test for three days teaches you what reliable code feels like. Refactor a tangled module and the shape of good architecture starts to surface.

Kent Beck calls this the transfer from synthetic to analytical skills. The synthetic work, the typing, the looking up of syntax, the figuring out which method to call, is where the analytical work gets earned. He says his father earned analytical skills through synthetic work that doesn’t exist anymore, and you can fail to make the jump if the synthetic work is gone before you get there.

Ben Werdmuller says it more bluntly: “friction is training.” Debugging, refactoring, and failure are what build engineers. Without that friction, the senior never forms.

The ladder existed because the base existed, the work funded itself without anybody having to plan it.

AI Is Turning the Pyramid Into a Diamond

That base is being compressed. Routine implementation, the work that used to feed the bottom of the pyramid, is the work AI is best at. The human work that’s left skews up the chain: intent, review, verification, accountability for what ships.

The signal is already in the data. Stanford’s Digital Economy Lab tracked ADP payroll records and found a relative employment decline for 22-25 year olds in AI-exposed occupations, while experienced workers in the same occupations stayed stable. Anthropic’s own labor market study found no broad unemployment spike, but a suggestive slowdown in hiring of young workers aged 22-25 in exposed roles. The U.S. Census CES working paper on early career hiring sees the same pattern in industry-state cells, with the appropriate caution that COVID, remote work, and monetary policy all complicate the causal story.

The BLS numbers tell the same story from a different angle. Narrowly-defined computer programmer roles are projected to decline, while the broader software developer category is still projected to grow. The labor that gets called “programming” is shrinking, the labor that gets called “engineering” is not, the shape is going from a pyramid to a diamond with a thin neck where the base used to be.

More Seniors Needed, Fewer Being Made

The new shape needs more senior judgment than the old one. Reviewing what AI produces, deciding what’s worth shipping, debugging weird emergent behavior across systems, that’s senior work. So is owning whether something actually works in production.

At the same time, the shrinking base gives fewer people the experiences that produce that judgment. Shen and Tamkin studied skill formation with AI assistance and found that when users delegate instead of engage, AI impairs conceptual understanding, code reading, and debugging. AI-enhanced productivity isn’t a shortcut to competence. Microsoft and Carnegie Mellon found something similar at the cognitive level, higher confidence in generative AI is associated with less critical thinking, and oversight skill atrophies if people never practice the underlying work.

The industry needs more senior engineers than ever, and it’s compressing the work that used to produce them. We’re running the senior pipeline at higher load on a base we’re actively shrinking.

I’ve started thinking about this as cognitive debt at career scale, when nobody coming up holds the theory of the craft anymore because they never did the work that builds it.

The New Ladder Has to Be Deliberate

I don’t have a clean playbook for rebuilding the ladder. Nobody does. The old one ran on accidental friction, and the friction is gone.

What I can name is the shape of the new reps. The senior skills that used to be earned through implementation work, taste, judgment, architectural instinct, debugging intuition, have to be earned through different work now. Juniors need reps in:

  • Writing intent. Specifications, plans, acceptance criteria. The work that comes before the code, where you decide what’s worth building and what tradeoffs you’ll accept.
  • Reviewing AI output. Not skimming, reviewing. Reading the diff like you wrote it yourself, asking what’s wrong with it, what edge case it missed, what it did that you wouldn’t have done.
  • Debugging emergent behavior. AI-generated systems fail in different ways than human-written ones. Practicing the debugging on systems you didn’t write end-to-end is closer to what the senior job actually is.
  • Verification and observability. Hills the AI can climb, as I wrote about before. Setting up the metrics, the tests, the targets that turn vague AI output into something checkable. Juniors can start practicing this without waiting for seniority.
  • Owning outcomes. Not “I wrote this function.” Owning that a workflow works, that a system stays up, that a metric moves. Take accountability earlier and the accountability instinct shows up earlier.

That’s the operating mode I’ve been calling Super IC at the top, and the onboarding craft one floor down. The new ladder is engineers practicing those skills earlier than they used to, on smaller scopes, with seniors and managers designing work that builds those skills on purpose.

Beck made the same case from the junior side last week in “Hey, N00b, We Didn’t Hire You to Complete Tasks”. His framing is sharper than mine: companies pay junior salaries today as the option premium on the senior they’ll become, and nobody cares how many tasks the junior completes. The deliberate gym is what makes that option worth something.

Which means seniors have a job to do too. Senior engineers and engineering managers have to decide which work to keep human, which work to keep visible, which reviews to slow down on purpose so the junior can read the code and ask why. That’s mentorship designed around AI-mediated work, not against it.

I don’t know if the industry will actually do this. The short-term throughput math says ship faster, use AI more, hire fewer juniors. Ten years out, the question is where the seniors are going to come from. Most companies pick the short-term answer because the long-term one is somebody else’s problem.

The strong teams will figure something out. The business-side folks will keep getting better at automating their own work. The pipeline question is real, and so is the answer most engineering managers don’t want to hear: the work that used to fill juniors’ calendars isn’t coming back, and the job is to design what fills it instead.

The industry still needs seniors, it’s dismantling the system that used to create them, and somebody has to design the new one.