The Junior Engineer After Code: Growing Engineers When Agents Do the Implementation

The thought experiment then unfolds: the requirements turn out to be incomplete, an intermediate migration proves irreversible, something is patched urgently at night, and bugs follow. Which of the two actually owns the system, and which leans entirely on the agent? Alexander splits the work into three layers. The artifact — a function, an interface, tests, configuration — is what the demo shows. The whole work episode covers the system's goal, an independent check, a controlled deploy, observation, and the consequences: when it falls apart, whoever built it is expected to fix it. System evolution over time is life with what you shipped. He illustrates that third layer with SRE engineers he knows who resign: the system has run for years, more and more features are wanted, reliability slides down the list, and every second night someone wakes to an alert to work out whether the failure is theirs or a neighbour's. Agents have made the first layer far cheaper, and the longer the horizon, the wider the gap between a junior and an experienced engineer.

The topic is personal for Alexander: his eldest son is twenty and is training as a game designer, while the youngest just started the preparatory school year, talks to the Alisa voice assistant natively, and finds a TV remote pointless. Then come the studies, with a caveat that they measure different things. A field experiment on a sample of almost five thousand developers gave 26% more tasks solved; a quasi-experiment at a group in the Alibaba ecosystem reported 67% more generated code among employees with under a year of experience; early users of Microsoft's tools opened roughly 24% more pull requests. But the tools there were 2023-era autocompletion, and they compare juniors with themselves without the tools. An analysis in Science across more than thirty million commits found that almost all the gain in shipped code and library adoption went to the less experienced. The acceleration also fades along the cycle: 180% more commits, 50% more increments inside projects, 30% more releases.

Anthropic's observational analysis of 400,000 Claude Code sessions gave about 15% confirmed successful sessions for beginner-level users against 28–33% for intermediate and expert ones. Alexander reads that gap not as junior versus senior but as expertise in the particular task: someone who speaks the language of accounting and separates problem space from solution space stays a domain expert even if their coding is weak. There is no universal grade defined by years, stack, and syntax any more — growth happens inside bounded episodes, where stack and libraries slip into the background. The trouble is that the lower rungs of the old ladder — simple, heavily specified tasks with a limited blast radius, a senior's review, and a round of rework — have moved to agents, which do that work end to end. That was the work that used to grow a newcomer, and a learning gap has opened in its place.

The gap closes only if the bounded episode goes to a junior with an agent rather than a senior with one — and the company has to want to design work that way. Alexander admits that as a small employer he does not see why he would take on a newcomer to teach from scratch when the same work can be loaded onto agents. Before delegating, the junior owes the feature's goal, a list of unknowns, a narrowing of the agent's task, and a fixed independent check; afterwards, a reading of the diff — a second agent may help parse it — an understanding of how the change reaches production, and accountability for its behaviour in operation. "Take a simple ticket from the backlog" no longer works: the simple tickets are gone. Alexander came across the idea of building a quiz and diagrams from the diff — a way to pull knowledge out of the task and close the feedback loop. The increment of a junior following the process and of one who asked a top model to make it nice looks identical; the difference is what the person understood.

Growth in the new picture means a widening unit of accountability: a fragment of a task, the whole task, a change the size of a pull request, a full episode where that pull request reaches production as a product increment, and ownership of a set of components or a service. A chat question — "I am a junior at a yellow bank and all the responsibility has landed on me" — gets read exactly through that ladder: the person was quietly made a middle engineer, and Alexander does not consider such a setup healthy. A junior lacks the experience of seeing which quick, simple decisions start firing six months later. As evidence he recalls a conversation with Misha from Alfa: after a restructuring, business people made the technical calls on one system for half a year, repairing it then cost around a million dollars, and after that the total-cost-of-ownership argument was easy to defend. Measurement around coding agents, meanwhile, stops at the pull request: releases and observation are not captured by field experiments, and measuring them is more realistic inside large companies with thousands of engineers.

Alexander looks for growth signals outside green pipelines: there is a joke about the layer between the computer and the keyboard, and someone who copies a chatbot's answer from a personal laptop into a green pull request formally looks fine. The substantive signs differ — they understand what the model answered, see that no regression crept in, need less help, can design a check themselves instead of leaning on an oracle, and can explain the essence of the task rather than say that the agent touched ten files. Hiring changes slowly, but Alexander would add a section where the candidate works in a pair with an agent, bringing their own harness and sharing a screen if they wish. Taking a junior comes with the obligation to teach: a mentor, a manager, a sandbox, a configured CI, and the ability to ship to production and roll back. Code has got cheaper; engineering judgment has not. The episode grew out of a request from Podlodka colleagues for a text about juniors, which became a longread that, in his words, nobody reads.