AI Is Making Junior Developers Faster, But Is It Making Them Better Engineers?

If AI can already draft code, fix bugs, and untangle unfamiliar systems, what’s left for junior engineers to learn the hard way?

We spoke with three experienced engineers: František Lučivjanský (Senior Principal Engineer), Kevin Antonio Moreno Melgoza (Senior Quality Engineer) and Maida Barlić (Staff Engineer), about how AI is changing the way junior developers learn, work, and build software.

Does speed in coding translate to speed in learning?

AI can help junior developers ship working code much faster than before. But the bigger question is: does writing code faster also mean learning faster? Our panelists have different views.

Kevin argues that AI does not accelerate learning. Programming, he says, is still learned through trial and error, while AI makes it easier to complete tasks without fully understanding them. Junior developers are particularly exposed because they are still building the foundations of their craft:

Developers who started before the AI era already went through that stage and learned by doing, so they already built that foundation. Juniors are still building it, so if they rely too much on AI, there is a bigger risk of skipping part of that process and ending up able to build things without fully understanding them.

František agrees that this risk exists, but believes AI can become a powerful learning tool if developers actively question its answers instead of simply accepting them:

Ask questions like: how does this work, what does this line mean, why is it done this way, what alternatives exist, can you explain it step by step, and can you quiz me about it afterwards? I would frame it like this: if we go into a meeting together and I ask you technical questions about the solution you built, can you explain it without AI? If yes, you are using AI well. If not, then you are only generating code, not really engineering the solution.

Maida also sees AI as a tool whose impact depends on how it is used. While it can encourage shallow learning, she points out that developers have long relied on frameworks without fully understanding how they work. Used intentionally, AI can make complex concepts easier to grasp:

I do think that AI can be very useful for learning because it can make concepts much easier to digest and help you understand them in a way that makes the most sense for you. You can also use it just to give you example of how to solve the problem, but still writing out code by hand as a part of the process of learning to be better developer.

In the end, all three agree that AI is just another tool. Whether it becomes a shortcut that weakens understanding or a tutor that accelerates learning depends entirely on how developers choose to use it.

Can you spot AI-generated code?

Experienced engineers can often tell when junior developers have leaned heavily on AI. The giveaway is code that works, but does so in a way that’s far more complex than it needs to be.

Kevin says AI becomes obvious when a simple task turns into an overengineered solution. It can help developers get through problems they might not have solved alone, but whether they actually learn from it depends on how they use it:

That can be very useful but the weakness is that learning becomes optional. It depends on the person, and some will use it as a way to learn, while others will just use it to finish the task and move on.

František has noticed similar patterns. AI often produces code that looks polished and well-structured, but he warns that appearance can be misleading. The real challenge is that AI tends to optimize for solving the immediate problem rather than considering the broader software architecture:

That is exactly why software engineers are still needed. Working code is not enough. We need people who can judge whether the solution is understandable, maintainable, and appropriate for the system.

Maida believes spotting AI depends on the size of the change. Small AI-assisted edits often blend in, while larger contributions can reveal familiar patterns. Like Kevin, she sees unnecessary complexity as a recurring weakness, although she also values AI for suggesting improvements and alternative approaches:

In my experience also, one common weakness is that AI code can be overly complicated for something simple. It can also sometimes suggest outdated approaches or use parts of a framework in a way that isn’t the most current. On the other hand, one of its biggest strengths is that it can suggest improvements, point out better ways to solve a problem, or offer ideas I might already be familiar with but haven’t thought of right away.

There are skills AI can’t learn for you

While AI can speed up development, the panelists agree that some skills still have to be learned the traditional way. Juniors still need solid programming basics to tell when AI is giving you the right answer – and when it’s confidently giving you the wrong one.

Kevin says junior developers should first understand the basics of the language, the framework, and the development practices they use. Without that foundation, it becomes much harder to tell whether AI is actually giving them a good solution:

A solution can work, but still not be what was really asked for, or not fit the project well. To identify that, you need that base knowledge.

For František, debugging is one of the most valuable skills juniors can develop. Learning to trace bugs, understand unfamiliar code, and reason through problems without immediately reaching for AI builds intuition that no language model can replace:

When I was junior, I recreated parts of frameworks just to understand how they worked internally. Today, AI can make that even more powerful. For example, try building your own small browser, framework, database, or even a simple LLM-related project. You will learn a lot, but only if you are not just letting AI do everything for you.

Maida also emphasizes reading code and debugging as essential skills. Even with AI writing parts of the implementation, developers still need to review pull requests, understand existing codebases, and verify that the final solution actually solves the problem:

It’s also important to learn how to test and verify your work, because AI can help you write code, but you still need to know whether it actually solves the problem. In the end, you should be able to start from any part of the codebase and work your way toward the problem.

What will companies look for in junior engineers?

While AI is changing how software is built, the panelists agree that it is also changing what companies will expect from junior engineers. Writing code will become less of a competitive advantage, while understanding, reasoning, and sound judgment will become increasingly valuable.

Kevin believes programming fundamentals will remain essential, but deep knowledge of a specific technology will matter less than the ability to think critically and evaluate whether a solution is actually the right one:

An expert in one technology can solve the same task as a junior with AI. Because of that, I think companies will value more people who can think critically, understand what is being asked, and judge if a solution is actually good or not. So strong fundamentals and good judgment will become more important, while knowing very specific details of one technology will become less important.

František expects coding skills to remain important, but no longer as the primary differentiator. Instead, he believes the strongest junior engineers will be those who can use AI effectively while understanding the tradeoffs behind every decision they make:

The strongest juniors will be able to say: “I tried multiple approaches, compared the tradeoffs, and I think this one fits best because…” So the signal will shift from “I can write code” to “I can use AI to build faster, but I understand what I built and can defend the decisions.”

Maida agrees that AI will make technical judgment even more valuable. Faster code generation does not reduce the need to understand systems, debug problems, or recognize whether AI has produced a correct and maintainable solution.

I don’t think technical depth becomes less important, if anything, it becomes more important to know what good code looks like and how to judge whether AI-generated code is actually correct.

Special thanks to our fellow colleagues at Infobip, the publisher of ShiftMag.dev, who participated in this article.