Here's a question that's been quietly nagging at the software industry: if AI agents are writing more and more of our code, how do junior developers actually become senior developers? This paper takes that worry seriously and proposes a concrete design direction.

The authors start with an observation most developers will recognize. A big chunk of what makes someone good at software isn't taught in courses — it's picked up sideways. You wrestle with a weird bug for three hours and end up understanding how DNS actually works. You read a colleague's PR and learn a pattern you'd never seen. You try the naive approach, it fails, and now you understand why the framework does the thing it does. Researchers call this incidental learning: knowledge you weren't trying to acquire, gained through the friction of doing real work.

AI coding agents remove that friction. That's the point of them — you describe what you want, they produce code, you move on. Great for productivity in the short term. But the paper argues that when developers delegate substantial coding tasks to autonomous agents, the muscles they used to build through struggle simply don't get exercised. Skills atrophy silently. The productivity gains are real, but so is the long-term cost: a generation of developers who ship a lot but understand less.

The paper's contribution is a design agenda for what the authors call agents that teach. Rather than treating "get the task done" as the sole objective, teaching agents would deliberately preserve moments of learning. Concretely, they sketch ideas like:

• Explaining the why behind a chosen approach, not just handing over the diff
• Occasionally pausing to ask the developer to make the judgment call themselves
• Surfacing alternatives that were considered and rejected, so the developer sees the tradeoff space
• Adapting how much scaffolding to provide based on the developer's apparent skill level

The key insight is a reframing: incidental learning isn't a nice-to-have side effect of manual coding — it's infrastructure for the software profession. If we build agents that optimize purely for task completion, we're quietly dismantling that infrastructure. The paper argues we should treat "did the developer learn something?" as a first-class design goal alongside "did the task ship?"

It's more of a research agenda than a finished system, but it names something important that the current wave of coding-agent papers has mostly ignored.