AI isn’t just writing our code; it’s rewriting how we learn to code.
Tools like Claude and Copilot can generate entire functions and refactor codebases in seconds completing weeks of dev work in hours.
But not everyone’s convinced it’s a good thing.
Critics argue we’re skipping the thinking part, the debugging, the tracing, the painful learning and losing the mental models that make us truly effective when things break.
But maybe that doesn’t matter. If the code solves the problem, do you need to understand every line?
AI is a productivity engine.
It scaffolds features faster than most juniors can Google.
We’ve always resisted abstractions. Developers grumbled about garbage collection, front-end frameworks and high-level languages. But productivity kept winning.
You don’t debug electricity to use a light switch. Maybe you don’t need to trace a call stack to ship a feature.
Maybe we just need to get better at steering, not understanding.
But there’s a cost.
You ask for a function and it works. But what did you understand?
When tools handle the hard parts; logic, structure and reasoning. Critical thinking quietly erodes.
“Users tend to develop automation bias, whereby they uncritically accept the suggestions or outputs of intelligent systems without engaging in reflective thought.”
— AI Tools in Society (MDPI, 2024)
Someone pastes in AI code, it works on the surface, but breaks in production and they can’t explain why.
This isn’t a tooling issue. It’s a cognition issue.
It’s like using GPS. You get where you’re going, but you never learn the route.
Heavy GPS use rewires how our brains process information, especially in the hippocampus, the region tied to memory formation and navigation. One study found habitual GPS use leads to worse spatial memory (Ruginski et al., 2020).
Just like GPS erodes spatial awareness, AI can erode cognitive function, not just in how we solve problems, but whether we think through them at all.
Some say this is just another abstraction, and they’re not wrong. We don’t write assembly anymore. We rarely manage memory. Abstractions let us build more by understanding less.
But old abstractions still required some internal model. You didn’t know how the CPU worked, but you knew why a loop froze the UI.
With agents, we might be heading toward abstractions that hide intention.
Maybe the best devs won’t be the ones who drop into the abstraction, but those who know how to question it.
Still, today, we assume understanding matters. Maybe agents will challenge this?
If AI handles all the friction, where will your intuition come from?
Thinking like a developer isn’t about writing code. It’s about understanding it. Asking better questions until something clicks. That separates engineers from operators: critical thinking, not just code completion.
It’s tacit knowledge; debugging, refactoring, reps, that sharpens instinct.
AI won’t stop you from learning, but it makes skipping easier. Weakening the mental muscle that makes coding intuitive.
Thinking like a developer means being curious, skeptical, adaptable, not knowing all the answers, but knowing how to explore.
AI can make you a better dev: if you treat it like a coach.
If you ask it to write, it will. But ask it to explain, compare, and critique. It sharpens your thinking.
Try this:
“What does this line do?”
“What’s the time complexity?”
“What edge cases break this?”
“What are 3 alternatives?”
Engage it that way, and you’re thinking.
Intention matters
If you’re shipping working code... does it matter?
Maybe not. For 0 to 1 problems, speed wins. For prototypes, shallow is fine.
But for production? Edge cases? Real users? Thinking matters. Context matters.
And most of all: intention matters.
You need to know why you’re writing the code.
Are you optimising for speed or mastery? Building for today or something that lasts?
If you want long-term impact and deeper skills, understanding still matters.
Real software isn’t just about shipping. It’s about knowing what to change, and how to recover when it breaks.
The best devs won’t out-code AI, they’ll out-question it. Spot subtle bugs. Carry deeper context.
Where this leads
If we stop thinking critically, the consequences won’t just be personal, they’ll reshape hiring, teams, and who gets to build software.
Here’s where we might be headed:
1. The Career Ladder Will Compress and Hiring Will Evolve
As AI makes it easier to appear productive without foundational understanding, junior roles will shrink and mid-level devs without system-level thinking will be automated out. The expectations for early-career developers will rise rapidly and hiring will shift to assess how candidates think, not just what they’ve shipped.
Interviews will move from remote LeetCode tests to real-time problem solving. Challenging developers to explain their reasoning, evaluate tradeoffs, and work with AI in the loop.
2. The definition of “Developer” will expand and the best will need to Think Bigger
AI enables non-technical roles to contribute directly to products. Not because they’ve learned to code, but because they already understand the domain. Business Analysts and Product Owners will use AI to translate their intent into working changes.
Meanwhile, the most valuable developers will go beyond implementation. They’ll specialise in systems thinking, architectural tradeoffs, and product nuance. Their edge won’t be syntax: it’ll be context.
As AI lowers the barrier to code, it raises the bar for comprehension. The ones who thrive will be the ones who ask: what are we building, and why?
