AI and Novices: The Danger of 'Never-Skilling' in Debugging

What happened?

A study published this year in The Next Web has identified a phenomenon called 'never-skilling': novice developers who rely on AI assistants (like GitHub Copilot or ChatGPT) to write code do not develop the necessary debugging skills. Unlike deskilling, which affects experts who stop practicing, never-skilling prevents beginners from acquiring basic competencies from the start. The study, based on interviews with recruiters and trainers, notes that juniors can generate code quickly but lack the ability to identify and fix errors. According to The Next Web, employers are already noticing that newly graduated candidates show gaps in fundamental skills, especially debugging and critical thinking.

Why is it important?

Debugging is a core skill in software engineering. Without it, developers cannot understand why code fails or solve complex problems. AI can generate functional code, but when an error arises, the novice does not know how to approach it. This creates a technological dependency that, in the long run, reduces software quality and innovation capacity. A 2023 study from Stanford University already warned that students using Copilot performed worse on code comprehension tests. Never-skilling exacerbates this problem: it's not that novices forget how to debug; they never learn. This has direct implications for security: according to a 2024 report from cybersecurity firm Snyk, AI-generated code contains 40% more vulnerabilities than human-written code, and developers without debugging experience cannot detect them.

Consequences for the industry

• Illusory productivity: novices appear productive by generating code quickly, but spend more time debugging errors they don't understand. A GitClear study (2024) found that using AI assistants increases writing speed by 55%, but debugging time doubles in teams with juniors.
• Skills gap: companies will face a shortage of senior developers capable of solving problems without AI. According to a Stack Overflow 2024 survey, 70% of senior developers believe juniors rely too much on AI, and 45% of recruiters report difficulty finding candidates with strong debugging skills.
• Security risk: AI-generated code can contain vulnerabilities that a novice neither detects nor fixes. An OWASP analysis (2024) of ChatGPT-generated code showed that 30% of snippets contained critical security flaws, such as SQL injection or buffer overflow.
• Long-term costs: technical debt accumulates when poorly debugged code is integrated into production systems. A McKinsey report (2024) estimates global technical debt could reach $1.5 trillion by 2025, and never-skilling contributes to this increase.

What should readers know?

It's not about rejecting AI, but using it as a complement, not a substitute for learning. Companies should implement training programs that ensure juniors acquire fundamental debugging skills, even if they use AI. For example, Google has introduced 'debugging sprints' without AI in its onboarding. Educators should redesign curricula to include debugging exercises without assistance, as MIT proposes with its course '6.031: Software Construction', which bans AI use in early stages. And developers themselves must be aware that AI is a tool, not a crutch. The Next Web study recommends that novices practice manual debugging at least 30% of their coding time during the first year.

"Never-skilling is more dangerous than deskilling because it affects an entire generation of professionals who will never develop the technical intuition needed to innovate," the study notes.

Historical context

This phenomenon recalls the dependence on calculators in mathematics: students who used them without understanding basic concepts struggled at advanced levels. In software, AI accelerates this process, but with broader consequences due to the complexity of modern systems. A similar case occurred with autocomplete IDEs in the 2000s, which reduced the ability to memorize APIs but did not affect debugging as much. Never-skilling is qualitatively different because AI not only completes code but generates it entirely, eliminating the need to understand underlying logic. Moreover, the adoption speed of AI is much faster: GitHub Copilot reached 1 million users in its first year, while IDEs took a decade to become widespread. This means an entire cohort of developers could be trained without ever debugging a complex error, which would have implications for innovation in critical areas such as artificial intelligence, cybersecurity, and embedded systems.