Junior engineers learned by doing the work agents now do in seconds. Stop hiring them and there are no seniors in ten years. Hire them and hand them an agent and they ship code they can't explain. Here's what we're trying instead.
Every senior engineer we know learned the craft the same way: years of small, slightly boring tasks. Fix this bug. Add this field. Write the migration. Figure out why the test is flaky. None of it was glamorous and all of it was training. You built a mental model of how systems fail by watching them fail at a scale small enough to be safe.
Coding agents now do most of those tasks in a few minutes and do them well. That's great for delivery and it quietly removes the bottom rungs of the ladder.
The industry is reacting in two ways and we think both are wrong. One is to stop hiring juniors - an agent is cheaper than a graduate and doesn't need onboarding. The other is to hire juniors, give them the same agents as everyone else and measure them on output. The first produces a profession with no seniors in ten years. The second produces juniors who can ship a feature in an afternoon and can't explain why it works.
We're a small, senior-heavy team and we've written before about why that shape works well right now. But a team made only of seniors is drawing down an account nobody is paying into. This post is about what we've changed in how we bring people up, what seems to be working and what we haven't figured out.
The failure isn't that juniors with agents write bad code. Often the code is fine. The failure is that the learning loop disappears.
Learning used to come from struggle. You wrote something, it broke, you spent two hours finding out why and the next time you didn't make that mistake. With an agent in the loop, the struggle is skipped. The code arrives working, or the agent fixes its own error before the human sees it. The junior gets the output and misses the part that would have taught them something.
We first noticed it in incident reviews. An engineer early in their career had shipped a change that held a database transaction open across a network call. The code had come from an agent and passed review, because the reviewer was looking at the diff and not the runtime behaviour. When we walked through it, the engineer could describe what the code did line by line but couldn't say why holding the transaction was a problem. They'd never been burned by it. Nobody had ever needed them to be.
The skill that's at risk isn't writing code. It's having a working model of what code does once it's running.
None of this is finished. These are the practices that have survived about a year.
Explain before merge. For engineers in their first couple of years, every pull request includes a short written explanation in their own words: what changed, why this approach and what would break if it were wrong. Not generated. Reviewers read it before they read the diff. If the explanation is thin, the review is a conversation, not a list of comments. It's slower and it's the single most useful thing we've done.
Deliberate unassisted reps. Pilots still hand-fly regularly even though the autopilot is better than they are, because the day the automation fails is the day they need the skill. We do the same. Part of a junior engineer's work each sprint is done without an agent - usually debugging, sometimes a small feature in an unfamiliar part of the system. It isn't about productivity. It's about keeping the muscle that notices when the agent is wrong.
Read the transcript, not just the diff. When a junior engineer works with an agent, a senior sometimes reviews the session itself: what they asked, what the agent proposed, where they accepted without questioning. This is where most of the mentoring happens now. The interesting moment is rarely in the final code. It's the point where the agent offered two approaches and the junior picked one without knowing why.
Own the things agents are bad at. We push early-career engineers towards work where judgement can't be skipped: writing evals and reading production traces, being on the rotation for incidents, sitting in on client discovery sessions. These are the places where you build a mental model of how systems behave and they happen to be the places where agents help least.
Write specs, then critique the agent's interpretation. We now treat the spec as the main artefact. Having a junior engineer write the spec and then review whether the agent's output matches it trains the skill that matters most: saying precisely what "correct" means before anything is built.
The old answer was cheap capacity for routine tasks. That answer is gone and anyone hiring juniors on that basis will find agents cheaper.
The new answer is closer to an apprentice forward deployed engineer. Junior engineers are often better than seniors at the parts of the job that need fresh eyes and time: sitting with users for a day, asking the naive question in a domain everyone else has stopped questioning, reading the whole of a legacy codebase instead of the part they need. Paired with a senior who owns the architecture, that's a very effective unit.
It also changes what we look for when hiring. We care less about how fast someone codes and more about whether they can explain a system they didn't build, whether they ask good questions when a requirement is vague and whether they notice when something looks right but isn't.
The economics. All of this costs senior time and in a small consultancy senior time is the product. We do it because the alternative is a team that can't renew itself, but we haven't found a version that's cheap.
Measuring progress. Output metrics are useless now - an agent-assisted junior can out-ship a senior on volume. We're judging growth through incident reviews, the quality of their written explanations and how often they catch the agent's mistakes before review does. It's qualitative and we're not confident it's consistent.
How long it takes. It used to take three to five years for someone to become a reliable senior. We don't know yet whether the new path is faster, because agents speed up exposure, or slower, because they remove the struggle. Ask us again in 2028.
Agents removed the routine tasks junior engineers used to learn from and nothing replaced them on its own. If you want senior engineers in five years you have to rebuild that path on purpose: written explanations before merge, regular unassisted work, mentoring through agent sessions as well as diffs and early ownership of evals, incidents and discovery - the work where judgement can't be handed off.
It's slower and more expensive than handing everyone an agent and measuring output. It's also the only version we've found where the people who join us early in their careers are actually becoming the engineers we'll need.