Skill Formation in the AI Era

A junior engineer, six months into the job, opens a pull request in review. The change is correct — tests pass, the diff is clean, the description even cites the ticket. The senior reviewing it asks one question: why this approach, and not the simpler one two files over that already solves something similar? The junior can explain what the code does, in detail, because they read every line the agent produced before pushing. What they cannot do is explain why it is the right approach for this system, because that judgment was never theirs to make. They delegated the decision along with the typing, and the version of themselves sitting in this review meeting never had to build the muscle that would answer the senior’s question.

This is not a hypothetical. It is the review most engineering managers are already running, whether or not they have named what is different about it. A decade ago, the same junior would have written the naive first draft themselves, hit the same design question the hard way at 2pm on a Tuesday, and arrived at review already having lived through the tradeoff the senior is now asking about cold. The work that used to force that collision — writing the boilerplate, debugging it by hand, discovering the edge case the slow way — is precisely the work an agent now does faster and, on average, more competently than the junior would have.

What the data actually shows

The most direct evidence on this question comes from a single Anthropic randomized controlled trial, published in early 2026, and it is worth being precise about what it found rather than repeating the headline. Fifty-two software engineers — mostly junior, all familiar with Python but new to a library called Trio — either completed a coding task with an AI assistant available or wrote the equivalent code by hand. On a follow-up quiz weighted toward debugging and conceptual understanding rather than syntax recall, the AI-assisted group averaged 50%; the hand-coding group averaged 67%. Elsewhere in this Library, that same finding appears twice, phrased two different ways — as the raw score gap here, and as “roughly 17% lower” in Volume IX’s chapter on engineering wisdom. They are not two studies. They are one seventeen-point gap, described once as scores and once as the difference between them.

Two qualifications matter as much as the topline number. The gap was not uniform across how participants used the assistant — it narrowed sharply for engineers who used it to ask questions and request explanations, and was widest for engineers who used it to generate code and move on, the pattern the researchers labeled delegation. And the single largest category gap on the quiz was on debugging questions specifically, not general recall — the exact skill a junior spends years building through the tedious version of fixing their own mistakes. Fifty-two engineers, one library, one quiz is not a verdict on AI-assisted learning generally. It is real evidence that how a junior uses the tool changes what they learn from using it, at a magnitude too large to file away as noise.

The expertise paradox, aimed at the junior specifically

Volume IX already introduced the term for this tension by name: DORA’s research program has warned of an expertise paradox, in which AI can close a knowledge gap fast enough to bypass the productive struggle deep expertise actually requires, producing what the report calls false expertise rather than the real thing. That framing was built for engineers generally. Applied specifically to someone six months into a first job, the paradox sharpens into something closer to a design constraint than an observation. A senior engineer who skips the struggle on one task still has years of prior struggle to draw judgment from when the next task breaks the pattern. A junior who skips it has nothing behind it — the shortcut is not a shortcut through the learning curve. For that one task, it may be standing in for the entire curve.

I was feeling so stupid because things that used to be instinct became manual, sometimes even cumbersome.

Luciano Nooijen, engineer, on working without AI assistance, quoted in MIT Technology Review

What the old apprenticeship path was actually doing

Volume IX’s chapter on engineering wisdom lays out the machinery this question needs without requiring it be built twice: tacit knowledge, in Michael Polanyi’s original sense, is judgment a person relies on without being able to fully explain it, and it has only ever moved through apprenticeship — modeling, in the cognitive-apprenticeship research of Collins, Brown, and Holum, where an expert’s normally invisible reasoning becomes visible because a novice can watch the process happen. The traditional junior-engineer path was a crude but functional version of exactly that mechanism, even though nobody designed it as apprenticeship on purpose. Writing the naive draft, watching it fail, getting corrected in review, and repeating that loop dozens of times a year was the modeling and the productive struggle happening at once, inside the same activity. What an agent removes is not the correction step. It is the struggle the correction used to be attached to — the part of the loop that built the instinct Nooijen describes losing.

Apprenticeship redesign, concretely

None of this argues for withholding AI tools from junior engineers, and neither DORA nor this Library’s own prior chapters make that argument. It argues that the loop apprenticeship used to run through by accident now has to be rebuilt on purpose, because the accident stopped happening by default. DORA’s own research proposes concrete shapes for that redesign rather than a general warning, and this Library’s chapter on workflow replay adds a third proposal, built specifically for AI-assisted work rather than adapted from pre-AI practice: turning the recorded session itself into the worked example a junior studies.

The first two rows are the least novel and the most testable. DORA’s own research frames deliberately preserving manual work not as nostalgia but as a design choice made with full knowledge of its productivity cost — assigning a junior one component to build without the agent’s help, specifically because the point of that task is not shipping it fastest but building the foundational understanding the rest of their work will lean on later. The second row changes what senior review is for. A review built to catch bugs in a diff and a review built to catch a junior’s blind delegation are different activities that happen to produce the same kind of comment thread. The second one has to ask why this, and not the alternative the agent never tried, on purpose — not as a side effect of catching a bug.

The replay row deserves the most unpacking, because it is the newest of the three and the one built specifically for this moment rather than adapted from pre-AI practice. Volume V argues that a scrubbable recording of an AI session is a genuine worked example in John Sweller’s sense — a novice studying a solved problem step by step learns faster than one solving it cold, because unguided problem-solving spends limited attention searching for a solution instead of learning its structure. Applied here, a junior watching a senior direct, correct, and reject an agent’s output — not just read the final diff — is watching the judgment step happen, even though they did not do the typing themselves. It will not replace writing code by hand. It may be the first mechanism built for exactly the gap that replacing it leaves behind.

What to check, not assume

A live, unresolved debate

None of this settles the underlying question, and treating it as settled would misrepresent the evidence this chapter has just walked through. Genuine, credible voices argue against the pessimistic reading. Developer Addy Osmani, in a widely circulated piece on junior hiring, argues that AI, used with deliberate mentorship, lets a junior see expert-quality code sooner and interrogate it — asking why a senior’s approach beats their own draft — rather than discovering the same lesson alone over months, provided a team actively resists what he calls vibe coding and keeps assigning some problems without the tool as a check against skill atrophy. Stack Overflow’s own engineering blog, writing on the same question from the hiring side, argues closer to the opposite: that AI risks eliminating what it calls the discovery phase of learning, “that precious, priceless part where you root around blindly,” and that no amount of mentorship fully substitutes for having gotten lost.

Both readings can be true in different organizations, or even for different engineers on the same team, which is precisely what makes this contested rather than merely under-researched. The Anthropic trial is fifty-two engineers on one library. The wider debate around it is younger than most of the tools it argues about. What is not contested is that the traditional apprenticeship path assumed a volume of manual struggle that is no longer happening by default — and a team that has not decided what replaces it has not solved the problem. It has only stopped noticing it.