Before generative AI, solving a programming problem could be frustratingly slow. I remember searching Google, going through Stack Overflow discussions, opening official documentation, trying one solution, discovering that it did not fit my situation, changing the approach and trying again.
Sometimes I started researching one problem and discovered something completely different that became useful months later.
And quite often, the exact answer simply did not exist. Another developer might have faced a similar error, but their application architecture, database, libraries or business requirements were different from mine. I had to understand several partial solutions and combine them into something that worked for my particular situation.
At the time, this felt inefficient. Looking back, I realize something else was happening.
That process was quietly training me to think like an engineer.
AI has removed much of that friction
Today, a university student or junior developer can copy an error into ChatGPT, Claude, Gemini or another AI assistant and receive a surprisingly good solution within seconds. That is progress. I would not suggest that developers stop using AI and return to spending hours searching the internet for problems that an AI assistant can explain immediately.
But there is an important question we should be asking: Did the developer solve the problem, or did the developer only obtain the solution?
The difference matters.
Stack Overflow's 2026 Developer Survey shows just how quickly AI has become part of normal software development. AI coding assistants and agents are now one of the dominant uses of AI among developers. About 63.8% of respondents use AI for debugging, troubleshooting or refactoring, while 56% use it to generate code in areas where they are unfamiliar. This means AI is increasingly involved precisely in the situations where developers historically learned by investigating problems themselves.
The old process was inefficient, but educational
When I searched for solutions before generative AI, I rarely found one perfect answer. I might find part of the explanation in Stack Overflow, discover the expected behaviour in official documentation, read a GitHub issue describing an edge case and then experiment inside my own application.
That process forced me to ask questions.
- Why is this happening?
- Which layer is responsible?
- Is the problem in the frontend, API, database or infrastructure?
- Why does one approach work while another fails?
- What assumption am I making?
Those questions slowly build technical judgment.
The failed approaches matter too. If you try three solutions and only one works, you do not simply learn the successful solution. You also learn something about why the other two failed. That knowledge stays with you.
Documentation teaches more than the answer you were searching for
There is another advantage to traditional research that is easy to overlook. When you open official documentation looking for one function, you often discover the surrounding system. You may learn about related methods, lifecycle behaviour, security restrictions, configuration options, performance considerations or limitations that you did not originally know existed.
AI is usually much more focused. You ask a question and it tries to give you the shortest useful path to the answer. That is extremely productive. But sometimes the surrounding information is where deeper understanding develops.
Interestingly, documentation has not disappeared from developer learning. Stack Overflow's 2026 survey found that 58.9% of developers still use technical documentation as a learning resource, making it the most-used source in the survey, while AI code-generation tools are close behind at about 53%. I think experienced developers should encourage that combination rather than asking new developers to choose between documentation and AI.
AI can improve learning, or bypass it
The problem is not the tool. The way we use it matters.
Compare these two questions:
"Fix this error for me." and: "Help me understand what could cause this error. Do not give me the final solution yet. What should I investigate first?"
Both use AI. But they create very different learning experiences. The first treats AI as a replacement for the debugging process. The second treats AI more like an experienced developer sitting beside you.
Microsoft Research studied 319 knowledge workers across different professions and found an interesting relationship: higher confidence in generative AI was associated with lower critical-thinking effort, while stronger confidence in one's own ability was associated with more critical thinking. The researchers also observed that AI changes critical thinking rather than simply eliminating it, moving more effort toward verification, integration and oversight.
This was not a developer-only study, so we should not treat it as proof that AI makes programmers think less. But it is a useful warning.
When obtaining an answer becomes extremely easy, deliberately thinking about the answer becomes more important.
Students can become faster without necessarily becoming stronger
There is early research specifically around programming education as well. A small controlled study involving ten computing students found that students using GitHub Copilot completed unfamiliar-codebase tasks about 34.9% faster and made more progress than when working without it.
But another observation was particularly interesting. The stronger students tended to be more selective with AI-generated code. They preferred smaller suggestions and evaluated them rather than simply accepting large generated blocks.
The study is too small to make broad claims about an entire generation of developers. But the behaviour makes sense. Experience changes how you use AI.
A beginner may ask: "Can AI solve this?"
An experienced developer is more likely to ask: "Does this solution actually make sense?" That second question is increasingly important.
Does software engineering education still matter?
AI has undoubtedly lowered the barrier to creating software. Someone with a background in business, finance, design or another field can now create websites, internal tools, automations, dashboards and even surprisingly capable applications without traditional software development experience.
I think that is a positive development. More people can turn ideas into working software.
But there is a major difference between: getting software to work and being responsible for software that must keep working.
Production systems introduce problems that are not obvious during initial development.
- Authentication and permissions.
- Data integrity.
- Security.
- Concurrency.
- Performance.
- Database migrations.
- Failure recovery.
- Privacy.
- Monitoring.
- Integration behaviour.
- Unexpected user actions.
- Long-term maintainability.
Stack Overflow made a similar distinction in its discussion of AI-assisted software development: AI makes prototyping and coding more accessible, but operating reliable software at scale still requires engineering expertise and ownership.
This is why I do not think AI reduces the value of software engineering education. I think it changes what that education should emphasize.
Maybe we should teach less syntax and more reasoning
If a university course spends most of its energy teaching students to memorize syntax that an AI assistant can produce instantly, that part of the curriculum will naturally lose value.
But computer science and software engineering are much bigger than syntax. Students still need to understand algorithms, data structures, databases, operating systems, networks, security, architecture, concurrency, testing and software design. More importantly, they need to learn how to reason about systems.
- Why this database?
- Why this data structure?
- Why should this API require authorization?
- What happens when two requests arrive at the same time?
- What happens when an external service fails?
- How could someone misuse this feature?
- What assumptions does this design make?
AI can help answer those questions. But the developer still needs to learn to ask them.
A better way for junior developers to use AI
I would not ask today's developers to recreate the slower learning environment I experienced. Instead, I would deliberately preserve the useful thinking that environment forced us to do.
A practical AI-assisted learning loop could look like this:
- Understand the problem before asking for the solution. Reproduce the issue, inspect the error and form your own initial theory.
- Ask AI for possible causes first. Instead of "fix this", ask what might be wrong and what you should investigate.
- Ask AI to explain the reasoning. Understand why the recommended approach works and what alternatives exist.
- Read the relevant documentation. Use AI to accelerate navigation, but still explore the official source when the technology matters.
- Change the conditions. Test another input, remove a parameter, change permissions or create an edge case. See whether your understanding still holds.
- Explain the solution back in your own words. If you cannot explain why it works, you may have solved the task without completing the learning.
This approach does not fight AI. It takes advantage of it.
AI can become one of the best teachers developers have ever had
There is another side of this discussion that is sometimes missed. Used properly, AI may actually be a better learning companion than the tools previous generations had.
Stack Overflow could answer a specific question. Documentation could explain a technology. Google could help find resources.
But an AI assistant can have an interactive discussion. You can say:
- "I still don't understand."
- "Explain this using a simpler example."
- "Give me a hint but not the answer."
- "Challenge my proposed solution."
- "Show me what could go wrong."
- "Ask me questions until I identify the bug myself."
That is extraordinarily powerful. The problem is not that today's developers have access to AI.
The problem would be using one of the most powerful learning tools ever created only as a shortcut for producing code.
The industry still needs engineers who can think without perfect answers
AI systems will continue improving. They will produce more code. They will understand larger codebases.
They will fix more bugs automatically. They may eventually handle much of the routine implementation work developers perform today.
That does not eliminate critical thinking. It moves critical thinking to a different level.
Someone still needs to evaluate whether the requirement makes sense. Someone needs to recognize when the architecture is wrong. Someone needs to challenge an insecure assumption.
Someone needs to understand the business context AI was not given. Someone needs to know when an AI answer that sounds extremely confident is still incorrect.
Stack Overflow's 2026 survey found that 93% of respondents consider the source behind AI-provided information at least somewhat important, while project requirements, code and technical documentation remain the most valued sources of context for AI.
That tells me developers do not simply need better AI answers. They need the judgment required to evaluate them.
The goal should not be learning without AI
I do not think the answer is nostalgia. The old way was slower. AI is better.
Students and junior developers should use it. Experienced developers should use it. I use it myself.
But there is one habit worth preserving from the pre-AI development experience: Do not outsource the thinking along with the typing.
Use AI to explore faster. Use it to explain concepts. Use it to challenge your assumptions.
Use it to generate alternatives. Use it to review your solution.
But understand what eventually reaches your codebase. Because the goal of the next generation should not be to become developers who can work without AI.
The goal should be to become engineers who can still think when AI is wrong.
