Learning the Craft

How do you learn to engineer when the agent writes the first draft? The craft doesn't disappear -- it inverts: fundamentals like systems thinking, debugging, and judgment matter more, even as syntax matters less. The risk is skill atrophy, especially for juniors; the upside is an always-on tutor that can make the craft more accessible. Which wins depends on how deliberately you teach.

The Pattern

"We're at the cusp of using AI for probably the biggest positive transformation that education has ever seen." -- Sal Khan (source)

The craft of software is learning the same way. How do you learn it when the agent writes the first draft? It doesn't disappear -- it inverts: systems thinking, debugging, reading code, and judgment matter more, while raw syntax recall matters less. Across ~400,000 Claude Code sessions, success tracked domain expertise, not coding background -- "expert" sessions reached verified success more than twice as often as "novice" ones (Anthropic). So a curriculum for the AI era teaches diagnosing and reviewing as much as writing, and uses the agent to learn faster rather than to skip learning -- treating its output "like an inexperienced intern: verify everything" (Osmani).

Why It Matters

Two forces pull against each other, and which wins depends on how deliberately you teach.

• The worry -- a missing rung. If juniors only orchestrate agents and never feel the code underneath, where does judgment come from? The grunt work that built intuition is exactly what agents absorb. Camille Fournier asks "how do people ever become 'senior engineers' if they don't start out as junior ones?", and Charity Majors warns that skipping junior training is "cannibalizing our own future" (via Osmani). Skill atrophies through cognitive offloading -- an effect that "always affects the youngest the most" (Thierolf).
• But the abstraction leaks. Moving up a layer is the craft's normal arc -- assembly to frameworks to agents -- and good developers always know enough of the layer below. AI coding is no exception: Joel Spolsky's law of leaky abstractions holds, so when the agent hallucinates or quietly rewrites your logic, you have to know what is really happening underneath (Spolsky). The fundamentals still have to be taught.
• And AI makes teaching them more accessible. A junior now has an always-on tutor inside the work. When a team's conventions and good patterns live in the agent's shared context (AGENTS.md, rules, worked examples), its suggestions carry "what good looks like" into the day-to-day -- easier to absorb than hunting through wikis. It is the democratization Khan Academy ran on education: video made lessons universal, and AI now personalizes them like a one-on-one tutor. Juniors miss the scar tissue seniors earned by failing for years, but a teacher on tap lets them learn faster and from more places -- the optimistic "revenge of the junior developer" (Steve Yegge, a coding-tools vendor).

The same embedded context pays off team-wide: a newcomer onboards by asking the agent to explain an unfamiliar codebase instead of waiting on tribal knowledge, and turnover hurts less -- when the conventions and the why live in shared context the team uses daily, that knowledge stops walking out the door with the person.

The honest tension: agents reward people who already have judgment yet absorb the tasks that build it. Teams that grow strong engineers stay deliberate -- preserve the fundamentals you delegate, give newcomers reps on understanding rather than just shipping, and put good patterns in the shared context so the tool itself teaches. Neglect it and it becomes the upstream cause of comprehension debt.

Last reviewed: 2026-06-26