I used to believe that the main risk for junior developers was writing poor code.

Fast forward a few more years into my journey, and I was mistaken; a much greater threat looms in the new frontier of Gen AI.

The real risk is that junior developers may not learn to think independently, and AI is making this problem worse. Recent research shows that developers who use AI assistants without a plan (and poignant intent) to learn remember much less than those who work through problems on their own.

A lot of junior developers use prompts to solve problems and deliver features, even if they don’t really understand how things work. The code might look fine, but something important is missing. These developers often can’t explain why the code works, change it when requirements shift, or fix it if something breaks late at night. The code runs, but their understanding isn’t strong enough to support their growth.

Before AI tools were everywhere, junior developers had to read documentation, search online, and debug by trial and error. It was slow and often frustrating, but that’s how real learning happened. Every error message was a clue, and every hour spent reading code helped you build mental models, even if you didn’t notice it at the time. Now, you can skip all of that by just prompting, pasting, and shipping code again and again.

That’s where the problem lies.

At Solvative, we’ve talked for years about how important it is to understand the "why" behind what you’re learning. AI can give you answers, write code, suggest patterns, and even create whole functions. But it can’t help you build the mental models you need to know when a pattern doesn’t fit your situation. It can’t teach you the intuition you get from debugging on your own, or the judgment you build through experimentation, making mistakes, and trying again. You only get that kind of learning by being curious and asking questions, even when you already have working code in front of you.

Here’s what curiosity looks like when AI generates code for you:

“This works, but what would happen if the input were null?"

"I see this uses async/await, why not callbacks here?"

"This function has three nested loops. Is there a more efficient way?"

"I don't understand this line. Let me trace through what it actually does.”

That last question is the most important. The junior developers who succeed are the ones who won’t ship code they can’t explain. They see AI as a starting point, not the final answer. They treat AI-generated code like a teammate’s pull request: something to review, question, and fully understand before merging. (Some of our team members remember reading conio.h)

After 15 years of building software with my team at Solvative, I’ve made plenty of mistakes and learned some lessons the hard way. One thing keeps coming up: shortcuts that save time now almost always end up costing more time later.

Letting AI write code for you without understanding it is the biggest shortcut of all. You might deliver faster today, but you’ll move more slowly tomorrow because you’re not building your own skills. You’re borrowing them, and borrowed skills often disappear right when you need them most.

If you're a junior developer reading this, here's what I'd suggest:

Try breaking things on purpose. When AI gives you working code, take time to read and understand it before you ship it. Figure out why it works and if it’s the best approach for your situation. If there’s a part you don’t fully understand, try rewriting it yourself and compare your version to the AI’s. You’ll learn something either way.

Try explaining the code to someone else. If you can’t clearly say why it works, even if you just talk it through in a voice memo, you probably don’t understand it well enough yet. That’s helpful to know. Check the documentation to fill in the gaps.

Keep asking “what if” questions. What if the data shape changes? What if this runs on a slower machine? What if someone calls this function with unexpected arguments? AI won’t ask these questions for you, so your judgment matters even more. Remember the old saying: garbage in, garbage out.

Read the official documentation. AI gives you summaries, but the details in the real docs often make the difference between code that just works and code that works well.

Try debugging on your own before asking AI for help. When something breaks, spend 30 minutes working through it yourself before looking for a quick answer. Those 30 minutes will teach you more than an instant solution ever could.

The developers who will be most valuable in five years aren't the ones who can prompt AI the fastest. They're the ones who understand systems deeply enough to know when AI is wrong, can design solutions that AI tools can't imagine, and can debug problems that don't match obvious patterns in training data.

You only reach that level after years of genuine curiosity, by asking “why” even when you already have a working answer. AI has made coding easier, which is exactly why curiosity matters more now than ever.

Junior developers who get this will become the senior engineers who lead teams. Those who don’t will end up relying on tools that change faster than they can keep up.

So, which kind of developer do you want to be?

None of this came from a single conversation or a lightbulb moment. The teams at Solvative have spent countless hours in discussions, meetings, and real-world trials – testing, debating, getting it wrong, adjusting, and testing again – to figure out the most responsible and effective way to put AI to work. This post is a reflection of everything we’ve learned together through that process. Thank you to every person on the team who pushed us to Solve Forward with AI the right way, not just the fast way.