I’ve heard this sentiment repeated multiple times: “Treat AI like a junior developer—give it small tasks that a junior developer can handle, and then review its output for correctness.”

Something about this mindset doesn’t sit right with me for a variety of reasons. For one, the likelihood of a large language model (LLM) or agent successfully completing such tasks tends to be low. You might counter with, “Well, if it gets me 70% of the way there, that’s still potentially valuable.” And to that, I would concede partially. However, what happens next presents a bigger, and largely overlooked, problem. That brings me to my second concern, which is arguably more consequential than simply dealing with subpar output from an AI agent. And it all boils down to feedback, learning opportunities, and incentive structures.

LLMs Don’t Learn

The only way to improve as a programmer is by writing more code—trying out different approaches, experimenting, failing, and learning. Progression as a developer is entirely about “time in the saddle.” It’s about struggling to fix an issue in 50 seemingly different ways, only to realize you’ve been calling the wrong function all along. These small, frustrating moments, combined with guidance from senior developers, add up over time to meaningfully alter the career trajectory of a junior programmer. It’s these experiences that unlock opportunities and, ultimately, create life-changing growth.

But here’s the thing: LLMs don’t learn. They don’t have career trajectories. They don’t grow or improve from their “code struggles” the way humans do. The small gains LLMs can achieve require expensive and time-consuming retraining or fine-tuning, not the kind of instant adaptability you’d get from a person learning on the job. Essentially, the feedback loop for an LLM is vastly larger and more complex. Sure, you can supplement an LLM by adding things to its context temporarily. But the more context you add, the less space you leave for reasoning. You can write a blog post or documentation as feedback, but there’s no guarantee the LLM provider will even scrape that content—or that it will make a difference amidst the vast sea of data.

In contrast, when you provide feedback to a human developer in a code review, they can immediately act on it, internalize it, and apply it moving forward. That feedback loop is valuable, immediate, and much more impactful than one with an AI model could ever be.

Using an LLM Doesn’t Help Anyone

There’s something very rewarding about the teaching process for both the student and also the teacher. Helping another developer reach a solution, or even just giving them the opportunity to try to get to a solution, can lead to growth. As a senior developer, that can be a huge motivating factor for why you keep doing what you do. At the end of the day, just letting ChatGPT or Claude implement it, leaves the senior developer more empty, and it leaves the junior developer without the valuable experience and guidance that they could have gotten from implementing the feature outsourced to the LLM.

One other thing you might say: “Well if the senior devs are using LLMs can’t the junior developers use it too? Won’t that help fill the experience gap?” and to that I’d say it also robs both the developers of their opportunities to learn social skills. The senior developer can use it as a venue to learn to teach while the junior can use it as another opportunity to learn to receive constructive feedback. These skills will become more and more valuable throughout both of their careers. In the same vein, halucinations are a real problem with LLMs. Juniors lack the experience to tell what is real and what isn’t coming from an LLM. That can be a very dangerous problem and there is no clear solution currently.

Ultimately this can be detrimental to the company as well. Training up juniors and getting them shipping code early as possible has a huge impact on their trajectory at a company. It gets them feeling ownership over the machinery providing business value sooner. Don’t let those task go to an LLM instead. Let the junior do it. Let them be proud of their work. Let them do what they do best: learn.

A Better Way Forward

So where do we go from here? As senior developers, we need to be more intentional about how we delegate tasks.

For unique or challenging tasks, hand them to junior developers or interns. They’re the ones who gain the most from tackling something new. On the other hand, repetitive or mundane tasks that everyone on the team has already done dozens of times? These are better candidates for automation, whether through AI (assuming it does the job reliably) or a deterministic script.

This approach isn’t just practical—it’s necessary. As AI tools become more entrenched in our workflows, the temptation to rely on them will grow. But we must resist the urge to sacrifice mentorship and junior development in favor of short-term convenience. If we fail to invest in our juniors, the gap between beginners and seniors will widen, and it will only become harder for new developers to climb the ranks. We should be working to smooth this learning curve—not steepen it.

Conclusion

The future of our industry depends on how we choose to invest in our people. Junior developers are the lifeblood of tech—they’re the ones who will eventually solve the problems of tomorrow. By empowering them to take on meaningful tasks and learn from experienced colleagues, we ensure not just their growth, but the long-term success of the entire field.

So the next time you’re assigning tasks, think carefully. Instead of reaching for an LLM to handle that feature or fix, consider giving it to a junior developer. Teach them. Guide them. Help them learn. The dividends it pays will far outweigh the perceived efficiency—and you may even find joy in the process.

Let’s not let AI rob junior developers of the opportunities they need to grow. Instead, let’s pave the way for the next generation. Let’s invest in our future.