Every senior engineer I know learned the same way: by doing junior work for years. The bug fixes, the small features, the boring refactors, the reviews where someone senior criticized their code in detail. That work was never just output. It was where judgment formed under supervision, with direct feedback, at low stakes. Automate the junior work and you do not just lose the output; you cut the input to the pipeline that produces senior engineers. Nobody announces this. The economics automate the junior work quietly, one task at a time.
How Judgment Actually Forms #
Judgment is not transferred by explanation.
It is grown by contact with consequences.
The Dreyfus model of skill acquisition describes the path: novice, advanced beginner, competent, proficient, expert, where each step up comes less from rules learned and more from experience absorbed.
The rules are the easy part.
What separates a competent engineer from an expert one is the set of cases they have lived through, the bugs debugged at 2 a.m., the refactor that made things worse, the outage traced to a decision the engineer personally made.
Apprenticeship was never ceremony.
It was how consequences reached the junior.
A junior shipped a small change, the change broke something, and the feedback arrived fast enough to teach them something.
Small scope, genuine stakes, tight loop.
Deliberate practice works the same way in every field studied: repetition at the edge of ability, with immediate feedback, is the only known mechanism that builds expertise.
The loop the old apprenticeship closed looks like this:
flowchart TD
X[Agent automates the junior work] -->|input cut| A[Junior ships a small change]
A --> B[Change meets actual consequences]
B --> C[Feedback arrives fast enough to teach them something]
C --> D[Judgment gains another case]
D -->|next task is a little harder| A
The junior work being automated is not adjacent to that mechanism. It is that mechanism.
The Economics Remove Exactly the Wrong Layer #
The uncomfortable part is that automating junior work is correct, locally. When an agent fixes the small bug in an afternoon for cents, paying a junior to spend a week on it looks like charity. No single manager makes a bad decision. Every decision is rational, and the aggregate is a pipeline with its input cut.
The pattern is familiar from The Shifting Bottleneck: automate a layer, and the constraint moves up. But this time the constraint does not just move. It loses its supply, because the layer above is built from the layer below.
The danger is the delay. A pipeline with no input still ships output for years, from the inventory of already-formed senior engineers. By the time the shortage is visible in hiring metrics, the training has been gone for a decade. The apprentice problem is a slow-motion staffing crisis that no quarterly review will catch, because the seniors are still performing.
The Same Collapse, One Level Up #
There is a structural precedent. Model collapse in code describes what happens when models train on their own output: the tails disappear first, the average looks fine, and the distribution narrows with each generation. An organization that stops training juniors runs the same loop on people. The seniors encode their judgment into systems and agents, the next engineers learn from those systems instead of from supervised contact with reality, and what they acquire is the smoothed average of their predecessors, rounded off a little more each generation. The rare cases, the exceptions, the reasons behind the rules are exactly what does not survive the transfer, and exactly what judgment was.
I am not claiming people are models. I am claiming the loop is the same structure: output consumed as input, without fresh contact with reality, degrades in the tails first.
What Replaces the Old Apprenticeship #
The answer is not to ban agents from junior work, that battle is over and nostalgia is not a strategy. The answer is that apprenticeship has to become deliberate now that it is no longer incidental. Three moves cover most of it.
Make juniors the supervisors, not the supervised writers. There is still a large amount of work that needs a human mind: reviewing agent output, verifying claims against evidence, catching the plausible-and-wrong. Put the junior on that work, with a senior reading their verdicts. The feedback loop is just as tight, judging output and being judged on the judgment, and the skill being trained is the one that actually remains scarce. The new junior work is acceptance.
Reserve work for humans on purpose. A team that assigns every task to whichever worker is cheapest has decided, implicitly, not to grow anyone. Some tasks should be reserved for the person who would learn most from them, at a productivity cost the team accepts knowingly. Software engineering teams in the age of AI makes the general case for keeping friction that pays; this is the specific friction that pays in people.
Teach judgment directly, out loud. The old pipeline taught judgment through absorption, through years of proximity. The deliberate version is faster and demands more from seniors: decision reviews, where a junior predicts the call before hearing it; postmortems walked through live, not archived; the why behind every convention made explicit instead of encoded and forgotten. Encoding your judgment into a system, the move Scaling Yourself Horizontally argues for, and transferring it to a successor are not the same act, and only one of them renews the supply.
What to Do Next #
If you run a team, trace one recent junior-level task end to end and ask who could do it next year for the first time. If the answer is nobody, because it will be automated, you have found a hole in the pipeline, and the fix is to route the learning part of that task somewhere it still exists.
If you are early in your career, stop competing with the machines on production and compete on acceptance. Build the record of catches, verdicts that proved correct, errors found in output everyone else approved. That record is the new seniority.
If you are senior, pick one person and start teaching out loud this month, decisions, not syntax. The foundations are a separate argument, and Learn the Foundation, Not the Syntax makes it, but foundations without direct consequences produce competence without judgment.
The question every organization is currently answering by default is: who is allowed to become senior next? Leaving that to the economics of task assignment is how the answer becomes nobody, slowly enough that no one notices until the last senior leaves.
See also #
- Scaling Yourself Horizontally - the upstream piece: encoding judgment into systems, and the warning that cheap systems consume the training that produces general judgment
- Model Collapse in Code - the same degradation loop at the corpus level, output training output, tails disappearing first
- Learn the Foundation, Not the Syntax - what to teach when production is automated: mental models of execution, cost, and failure rather than syntax
- Software Engineering Teams in the Age of AI - the team-level case for keeping friction that pays, of which training juniors is the clearest instance
- The Shifting Bottleneck - the general pattern of constraints moving up when a layer is automated, here with the twist that the upper layer loses its supply
- The Acceptance Gap - the acceptance work that becomes the new way juniors train, generation solved and judgment remaining
References #
Dreyfus model of skill acquisition - the novice-to-expert progression, where advancement comes from absorbed experience rather than rules