Here's a scenario that's becoming more common than anyone wants to admit.
A junior developer gets stuck on a problem. Instead of sitting with it — reading the error, forming a hypothesis, checking the docs — they paste it straight into ChatGPT. They get an answer. It works. They move on.
This happens five times a day. Every day. For months.
On paper, they're productive. PRs are getting merged. Features are shipping. But something is quietly not happening: they're not learning to debug. They're not building the mental model of how the system actually works. They're not developing the instinct that tells you why something broke, not just what to paste to fix it.
And when the AI gives them a wrong answer — which it does, regularly — they can't tell.
The crutch you don't notice you're using
The problem with AI as a crutch is that it doesn't feel like a crutch. It feels like efficiency.
There's no obvious signal that something is wrong. The code compiles. The tests pass. The feature ships. The feedback loop that would normally tell you "you don't understand this yet" gets bypassed entirely, because the output looks correct even when the understanding isn't there.
Senior engineers can use AI tools heavily and stay sharp — because they have enough depth to evaluate the output, catch the mistakes, and direct the tool deliberately. They know what good looks like. They know when to trust the suggestion and when to push back.
Juniors don't have that depth yet. That's not a criticism — it's just where they are in the learning curve. The issue is that AI tools don't know the difference. They give the same answer to someone who understands the problem and someone who doesn't. And the junior who accepts the answer without understanding it isn't closing the gap. They're just hiding it.
What fundamentals actually means
"Learn the fundamentals" sounds like something a grumpy senior engineer says when they don't want to explain something. Let me be more specific about what's actually at risk.
Debugging instinct. The ability to read an error message, form a hypothesis about what caused it, and systematically test that hypothesis. This is not a skill you're born with. It's built through repetition — through being stuck, trying things, being wrong, trying again. Every time you skip that process, you miss a rep.
Mental models. Understanding not just that something works but why it works. Why a hash map gives you O(1) lookup. Why a useEffect with the wrong dependency array causes infinite renders. Why your database query is slow. These models are what let you reason about new problems you've never seen before — which is most of what senior engineering actually is.
Reading code. Real codebases are messy. They have naming that made sense to someone three years ago, patterns that evolved organically, and decisions that are only understandable in context. Learning to navigate that — to read code you didn't write and didn't choose — is a skill AI cannot develop for you.
Knowing when you don't know. This might be the most important one. Experienced engineers have a calibrated sense of uncertainty. When they're unsure about something, they know they're unsure. Juniors who've been leaning on AI often have the opposite — they're confident about things they don't actually understand, because the tool provided an answer and the answer worked.
The interview will find the gap
This is where it becomes concrete.
A junior developer who has shipped features for six months entirely on AI assistance walks into a technical interview. The interviewer asks them to debug a piece of code on a whiteboard — no tools, no autocomplete, no paste-into-ChatGPT. Or they ask them to explain why they chose one approach over another in a project they claim to own.
The gap surfaces immediately. Not because the candidate is unintelligent — but because the reps weren't there. The reasoning wasn't practiced. The mental models weren't built.
And the frustrating part is that the candidate often doesn't see it coming. The daily workflow felt productive. The code was shipping. Nothing in the feedback loop signaled that something was missing.
Until the interview did.
AI tools aren't the enemy — the habit is
None of this means don't use AI tools. That would be both impractical and unnecessary.
The tools are genuinely useful. They eliminate boilerplate, unblock syntax questions, suggest approaches you might not have considered. Used well, they make you faster at the parts of development that don't require deep thinking — which frees up more time for the parts that do.
The habit that's worth breaking is the one where AI is the first response to difficulty rather than a resource you reach for after you've attempted to think it through yourself.
Try to solve it first. Give yourself ten or fifteen minutes with the problem before opening a new tab. Form a hypothesis. Check the docs. Read the error message carefully, the whole thing, not just the last line. Then, if you're still stuck, use the tool — but use it to check your thinking, not to replace it.
That distinction sounds small. Over months, it's the difference between a developer who can reason independently and one who can't function without the assistant.
The developers who will be fine
The junior developers who are going to come out of this period well are not the ones who avoided AI tools. They're the ones who used them without outsourcing their thinking to them.
They shipped faster because of AI. They also spent time on hard problems without it. They read documentation. They debugged without pasting. They built things from scratch occasionally, on purpose, even when a generator could have done it in thirty seconds.
They stayed curious about the why, not just the what.
The market is hard right now. Getting a junior role is genuinely difficult. But the developers who build real depth during this period — even without a job, even while building side projects alone — are the ones who will be very hard to pass over when the market opens back up.
The gap between "used AI to ship things" and "used AI to ship things and still understands what I built" is enormous. And it's entirely within your control.
Do you have a rule for when you let yourself reach for AI and when you don't? I'm curious how other junior and mid-level developers are thinking about this.
Top comments (0)