The traditional apprenticeship model in software engineering had a built-in progression. Easy tasks first, hard tasks later. You started with bug fixes, small features, well-scoped tickets. Not to protect you. Because that work built the judgement you'd need for the harder stuff. You learned the codebase by reading it. You learned the patterns by following them. You earned the flamethrower by starting with a match.

AI has collapsed the bottom of that ladder. The easy work is now handled faster and more cheaply by an agent. Which means juniors are being handed the flamethrower on day one, without having learned what fire does.

The tools amplify whatever judgement you bring. For a senior engineer, that's leverage. For a junior without the foundational experience, it's acceleration in the wrong direction. They can generate more output than ever before. They can't tell whether it's good.

This isn't a new problem. Every industry that went through automation had this conversation. What's interesting is that they didn't all land in the same place.

Accounting

Spreadsheets killed the bookkeeper. Junior accountants used to spend years on manual calculation. That work disappeared. But accounting didn't. It moved up. Juniors now learn interpretation and judgement earlier. The apprenticeship survived; the content changed.

Architecture

CAD eliminated the drafting table. Junior architects spent years on technical drawing as the foundation of their craft. Some argue they're worse architects for losing it. Others argue the drafting was never really the point. Design thinking was. The jury's still out.

Medicine

Surgery residents still learn by doing, on actual patients, under senior oversight. The industry decided the skill couldn't be simulated. The stakes were too high to shortcut the formation. Software might be having that conversation soon. Except software mistakes are usually recoverable in a way surgical ones aren't, which changes the calculus.

Pilots

The most studied version of this problem. Autopilot has been degrading manual flying skills for decades. There's a name for it: automation complacency. Pilots who rely on autopilot lose the muscle memory and situational awareness to take over when it fails. The industry's response: mandatory manual flying hours. Intentional constraint as policy, not preference. The software equivalent hasn't been mandated anywhere yet.

Chess

The optimistic counterpoint. After computers became unbeatable, did chess players get worse? No. Better. Engines gave players a perfect feedback loop against something that never got tired and always knew the best move. The tool accelerated learning rather than replacing it. Maybe agentic development does the same for engineers who use it deliberately. The question is whether most people use it like a chess engine or like a crutch.

Photography

Film had a built-in constraint: cost per shot. That constraint forced deliberate composition. You thought before you clicked. Digital removed the cost of a bad shot, and some argue it removed the discipline with it. The volume of output exploded; the quality of thought per frame dropped.

Radiologists

AI now outperforms humans at reading certain scans. The specialty is actively debating whether residents should still learn to read scans manually, and if so, why. The answer the field keeps landing on: because the machine might be wrong and you need to catch it. That's the same argument for why engineers need to understand the code the agent writes.

Seven industries, seven different responses. Some let the apprenticeship evolve. Some mandated the old skills anyway. One found the tool made people better. None of them agreed.

Software engineering is somewhere at the beginning of this conversation. The question isn't whether agentic tools change how juniors learn. They already have. The question is what we do about it.

Maybe the new generation learns differently, not worse. Maybe you don't need to write a migration by hand to understand what migrations do.

Or maybe we're about to find out the hard way that you can't skip the foundation. And the evidence will show up as a generation of engineers who can generate anything and debug nothing.

Nobody knows yet.