The Disappearing Apprenticeship
AI short-circuits the loop where engineers used to build judgment — and the team quietly stops developing it.
What it is
Junior engineers used to develop judgment by struggling — trying the wrong approach, hitting the wall, asking a senior, refactoring, learning. AI cuts the struggle out. The junior gets working code in five minutes. The struggle was where the judgment lived, and the junior never has it. Five years in, they’re a different kind of engineer than the ones who came up before — and the team is missing a layer it didn’t notice losing.
How it happens
AI is genuinely helpful. The senior was busy anyway. The junior shipped the feature. The metrics looked good. Nobody had a meeting where “we should make sure people are still struggling enough to learn” was on the agenda — because that sentence sounds insane on its face. So the loop kept tightening, session by session, until the formative struggle was gone and nobody could remember when it left.
The AI mechanism isn’t malice; it’s optimization. AI optimizes for “task complete,” which removes the friction that used to produce skill development. It’s perfectly aligned with the immediate goal and perfectly misaligned with the long-term one. The junior gets the answer before forming the question; the question is where the judgment would have grown.
Why it’s dangerous
The pipeline of senior engineers depends on juniors becoming mid-level becoming senior. If juniors aren’t building the underlying judgment — about design, about tradeoffs, about when AI is wrong — they’ll plateau at “AI prompt operator” and the team’s depth, five years from now, depends on whether anyone is doing the work that develops the next layer of judgment. The cost lands on the team that no longer has anyone who can override the AI when it confidently produces the wrong architecture.
This isn’t a “kids these days” complaint. It’s a structural issue with the feedback loop. Same juniors as five years ago, same talent, differently shaped loop, different output. The AI-era hinge: pre-AI, friction in learning was inescapable — you had to struggle to ship. Post-AI, friction has to be intentional, or it doesn’t happen, and intentional friction has to survive a quarterly velocity review.
How to prevent it
The fix isn’t less AI — it’s a different mode of AI. The same model that hands a junior the answer can coach them to it instead, given the right prompt. “Ask me Socratic questions until I figure this out” produces a vastly different developmental outcome than “write this for me,” using the same tool. The senior’s job is to make that mode the default for development work, and to name out loud when a task is for shipping versus for learning.
Scale to stakes: some work is throughput — use AI to the maximum. Some work is the load-bearing architectural decision the next senior needs to have wrestled with — AI assists by coaching, not producing. Throwaway scripts don’t need apprenticeship work; the decisions that will define the codebase in five years do. The friction signal is the engineer who can answer “what does the code do?” but not “why is it shaped this way?”
The serious team fix
Three things, reinforcing each other:
- A team habit of naming stretch work explicitly. For each engineer, some work is throughput (ship it, AI allowed) and some is development (learn it, AI as tutor only). The senior names which is which at assignment, in writing. Code reviews on stretch work ask “what did you learn?” not just “did it ship?” The distinction is part of the team’s normal language, not a special-occasion conversation.
- An AI-leveraged Socratic tutor mode. A slash command or skill tuned to ask questions instead of providing answers — point it at the problem the engineer is stuck on, and it walks them through the reasoning rather than handing them the code. Same model, different prompt. The AI becomes the patient, available mentor every junior needs and no senior has time to be at scale.
- A protected development track with AI-era-specific structures. AI-off design review hours where engineers work through tradeoffs without a chat tab open. Architectural decisions juniors own end-to-end, with AI restricted to research mode. Mentorship pairings, stretch-project rotation, and a time budget that isn’t entirely filled with throughput work. The org makes development of judgment a first-class deliverable, with named owners and visible time — calendar structure, not a vibe.
The shift is: AI made writing code cheap. Make sure developing engineers stayed expensive on purpose — because the next generation of seniors is the only thing that can save the team from being entirely steered by the median pattern in the model.