Juniors used to learn the hard way. Now someone has to teach them on purpose.
Engineering judgement used to come bundled with the struggle of getting code to work. Coding agents made the struggle optional, so the judgement has to be handed down deliberately. What seniors can pass on, what juniors should practise, and the evidence for both.
Think about how you learned what good code looks like.
Probably not from a course. You learned it from a stack trace you stared at for an hour, from reading a library’s source because its docs were wrong, from a senior who rewrote half your pull request and left a comment explaining why. Nobody planned any of that as teaching. It happened because getting code to work was hard, and the hard part forced you to understand it.
A coding agent now gets the code working first. The struggle that used to teach is optional, and the judgement it used to produce doesn’t arrive by itself any more.
What the evidence says
Anthropic ran a randomised trial on exactly this. 52 mostly junior developers learned Trio, a Python library none of them had used. Half had an AI assistant and half coded by hand, and afterwards everyone took a quiz on the concepts they’d just used.
The AI group averaged 50%, against 67% for the people who coded by hand. The biggest gap was on debugging questions, which is the skill you need most when you’re checking code someone else (or something else) wrote.
The detail that matters is who did well anyway. The participants with AI who scored highly asked follow-up questions, asked for explanations, and used the assistant to understand the code as well as to produce it. How they used the tool made the difference, and that can be taught.
Faster, in both directions
An agent makes a good engineer faster. It makes a bad habit faster too. A developer who never checks edge cases now skips them across 10 files in an afternoon instead of one file in a day.
So the question for a team lead is which habits the juniors are building, because the tool will amplify whichever ones they have.
What seniors can hand down on purpose
Most of what a senior knows was never written down. It used to leak out through code review and through sitting next to people. With agents writing more of the code, those moments get rarer, so they need doing deliberately.
Explain the rejection. When you turn down a change, say what you saw that made you turn it down. “This works, but it’ll break when the list is empty” teaches more than a rewritten diff.
Show what you check. Before you trust an agent’s output, you look at something: the test it added, the error path, the query plan. Say out loud what you looked at and why that was enough. Juniors can’t copy a check they never see.
Review together. Pair on reading and judging code, since the typing is the part the agent does now. 20 minutes going through an agent’s pull request with a junior beats an afternoon of them generating code alone.
Write the reasons into the repo. Decisions you’d otherwise repeat in every review belong in the instructions file at the root of the repository, with the reason next to each rule. Agents read it at the start of every session, and so can new people.
What juniors should practise
Write your answer first. Before you ask an agent for something, sketch what you think the solution is, even roughly. Then compare. The gap between your sketch and its answer is where you learn.
Ask why after it works. Working code is where the learning used to end, and now it’s where it should start. Ask the agent to explain the parts you couldn’t have written yourself.
Debug without it sometimes. The trial’s biggest gap was in debugging. Take a bug you could hand off, and find it yourself first. You’ll be slower, and you’ll get better at the thing you’ll need when the agent is confidently wrong.
Make it part of the job
None of this happens if juniors are measured only on how much they ship. A team lead who wants juniors with judgement has to leave room for the slow parts: the sketch before the prompt, the review that explains, the bug found by hand.
If nobody hands it down, you get a team in a few years that can ship anything and can’t tell you which version is good. Teaching it on purpose is how you avoid that. It’s also what the coding-agents half of the AI Engineering Workshop covers: a team working with its own coding agent, and learning what to check before it trusts what comes back.