Onboarding a junior next to an agent that does their old job

An engineering manager at a logistics company raised a worry with me that he had not seen coming. He had a new junior engineer, and he realized that the tasks he would normally have given her to learn on, the small, well-defined pieces of work that build competence, were exactly the tasks the team now handed to the agent. The simple bug fixes, the boilerplate, the small features with clear specs, all of it went to the agent because the agent was faster at it. Which meant his junior had nothing to cut her teeth on. The bottom rungs of the ladder she was supposed to climb had been removed, because those rungs were now the agent’s job, and he did not have a replacement path to competence to offer her.

Competence was built on the simple work

The path from junior to senior engineer ran through a lot of simple work. You fixed small bugs, wrote boilerplate, implemented well-defined features, and in doing so you learned. You learned the codebase, the patterns, the way things fit together, the feel of the tools, the taste for what good looks like. The simple work was not just output, it was the training ground, the place where competence was slowly built through repetition on tasks small enough to handle and real enough to matter. Every senior engineer climbed that ladder, rung by rung, and the rungs were made of simple work.

Agents are best at exactly that simple work, so teams naturally route it to them, and in doing so they remove the rungs. The junior arrives to find that the tasks that would have built her competence are being done by the agent, faster and cheaper, and there is no obvious path for her to learn on. She could watch the agent do the work, but watching does not build competence the way doing does. She could take on harder work, but she is not ready for it, precisely because she skipped the simple work that would have prepared her. The ladder has lost its bottom, and the team has not built a new way up, because the old way was so automatic that nobody thought of it as something that could be removed. The work the junior learned on became the work the agent does, and the learning went with it.

This is a real and near-term problem, not a distant one. A team that routes all the simple work to agents and hires juniors anyway will find those juniors are not developing, because the mechanism that developed juniors was the simple work. And a team that stops hiring juniors because agents do the entry-level work is quietly deciding not to grow the seniors of the future, since seniors are grown from juniors who had somewhere to learn.

Build a new path to competence

The lesson is that if agents take the simple work that juniors learned on, the team has to build a deliberate replacement path, or it will stop producing competent engineers. The learning that used to happen automatically now has to be arranged on purpose.

What teams do to grow juniors alongside agents.

Give juniors work chosen for learning, not just for output, even when an agent could do it faster, because the point is their growth.
Have juniors review and understand agent output deeply, turning the agent’s work into a text they learn from rather than a black box.
Pair juniors with seniors on real problems, so the mentorship that the simple work used to carry happens directly.
Make understanding, not just shipping, the measure of a junior’s progress, since the agent can ship and only the junior can learn.
Protect the time for juniors to build competence, resisting the pull to route everything to the agent for short-term speed.

The simple work was a training ground disguised as output. When the agent takes the output, the training ground has to be rebuilt intentionally, or the pipeline of future seniors quietly closes.

How we think about it at Density Labs

The junior with no rungs to climb is one of the more serious second-order effects of AI tools, and it is easy to miss because it plays out slowly. The team routes the simple work to the agent for good short-term reasons, and in doing so it removes the exact tasks that turned juniors into seniors, without building a replacement. The cost does not show up this quarter. It shows up in a few years, as a shortage of senior engineers who were never given a way to grow.

When we help teams adopt AI tools thoughtfully, we raise the question of how juniors will develop when the agent does the entry-level work, because a team that does not answer it is deciding, by default, not to grow its own people. The path to competence has to be rebuilt deliberately, since the automatic one is gone.

The simple work was how juniors became seniors. Hand it all to the agent, and you have to build a new ladder, or you stop making seniors.