This is not alarmism. Recent research from MIT and Anthropic is confirming a counterintuitive fact: the more you use AI to write code, the weaker your abilities may become.
1. The Speed Illusion: What Feels "Faster" Is a 40-Point Misperception
Anthropic and METR ran a disturbing randomized controlled trial in 2025. 16 experienced open-source developers were assigned to an AI-assisted group or a human-only group, completing 246 real development tasks.
The result? The AI group was actually 19% slower than the human-only group. Ironically, these developers predicted they would be 24% faster, and in post-hoc reviews they still believed AI had made them 20% faster — a 40-percentage-point gap between perception and reality.
This is not an isolated case. A causal analysis from Tilburg University on GitHub Copilot found that after Copilot's introduction, "core developers" increased their code review workload by 6.5% while their own code output dropped by 19%. AI lets less experienced developers produce more, but at the cost of senior developers' cognitive load — they spend more time reviewing AI-generated code of uneven quality.
Another independent Anthropic study (Shen & Tamkin, 2026) is even more direct: 52 professional developers learning a brand-new async programming library; the AI-assisted group's comprehension dropped 17%. The most dangerous area was debugging — when code broke, developers accustomed to relying on AI could barely find the problem themselves.
The problem isn't that AI writes slowly. The problem is: you feel stronger when you are actually getting weaker — and you don't even realize it.
2. Your Brain Is Being "Outsourced": MIT's EEG Research
If Anthropic's experiments are a behavioral warning, MIT's research reveals the neurological truth.
In Kosmyna et al.'s 2025 "Your Brain on ChatGPT" (arXiv:2506.08872), 54 participants used different tools for writing tasks over 4 months while EEG monitored brain activity. Three groups: LLM, search engine, and brain-only.
The results were stark:
- The LLM group's brain connectivity dropped 55% (~47% in the alpha band), approaching sleep-state activity levels
- 83% of LLM users could not quote what they had "written"
- Even more shocking: after AI assistance was withdrawn, 78% still could not quote — the cognitive damage is not temporary but persistent
- Carefully read requirements at task start
- Verified LLM answers before working independently
- Made fine-grained edits when copy-pasting
- Fine-grained, context-sensitive navigation
- Skipped initial understanding, went straight to copy-paste
- Repeatedly revisited the LLM's answers
- Adopted erroneous information even after hesitating
- Coarse navigation, relying on visual cues (because they didn't edit, only copied whole blocks)
- Trait: pasting AI output straight into the codebase without edits or verification
- Consequence: per CHI 2026, the primary behavioral indicator of overreliance. You skip understanding and learning.
- Outcome: cognitive debt accumulates, long-term capability decays
- Trait: think independently first; use AI for "proof of concept" or "direction exploration" when stuck
- Benefit: per MIT, neural connectivity rises under this order
- Key: AI's output is an extension of your thinking, not a substitute
- Trait: independently design architecture and write core logic; only consult AI for implementation details or edge cases
- Benefit: per Anthropic, comprehension stays intact and debugging ability is strongest
- Core principle: you think, AI accelerates
- Kosmyna, N. et al. (2025). "Your Brain on ChatGPT: Accumulation of cognitive debt when using an AI assistant for essay writing task." *arXiv:2506.08872*. MIT Media Lab.
- Becker, M. et al. (2025). "The Effects of AI Assistance on Software Development: A Randomized Controlled Trial." *METR / Anthropic*.
- Shen, Z. & Tamkin, A. (2026). "Developer Comprehension Under AI Assistance." *Anthropic*.
- CHI 2026. "Behavioral Indicators of Overreliance During Interaction with Conversational Language Models." *ACM CHI Conference*.
- Storey, M.-A. et al. (2026). "Triple Debt Model: Technical, Cognitive, and Intent Debt in AI-Accelerated Software Development." *arXiv:2603.22106*.
- He, J. et al. (2025). "The Impact of AI on Developer Productivity: Evidence from GitHub Copilot." *Tilburg University*.
- Osmani, A. (2026). "Comprehension Debt: The Hidden Cost of AI-Generated Code." *O'Reilly Radar*.
- "Mitigating Epistemic Debt in Generative AI-Scaffolded Novice Programming." *arXiv:2602.20206*.
- Addy Osmani on Cognitive Debt: https://www.aicerts.ai/news/cognitive-debt-the-hidden-cost-of-ai-coding/
However, the study found a way out: order of operations matters more than total usage. Those who worked independently first, then used AI saw neural connectivity rise. Those who went straight to AI showed the steepest neural decline.
This points to a core principle: AI should extend your thinking, not replace it.
3. Initial Anchoring: Why the First Answer Is the Most Dangerous
A CHI 2026 paper, "Behavioral Indicators of Overreliance During Interaction with Conversational Language Models," reveals another overlooked mechanism.
Researchers had 77 participants work with an LLM intentionally seeded with errors on three real tasks (quiz solving, article summarization, trip planning). By tracking every click, scroll, and copy-paste, they identified five behavioral patterns associated with overreliance:
Low-dependence users:
High-dependence users:
The key finding: the LLM's fluent, authoritative, single-answer style reduces users' willingness to scrutinize and "anchors" them to the first answer. When AI speaks quickly and confidently, the human brain switches off verification mode — a cognitive form of "autopilot."
4. An Engineering Definition of Cognitive Debt: Not Just "Technical Debt"
In Addy Osmani's O'Reilly article "Comprehension Debt: The Hidden Cost of AI-Generated Code," software engineering researcher Margaret-Anne Storey's definition is cited:
> "Cognitive debt is the accumulating cost due to increasing cognitive load on a codebase, raising the cost of software evolution."
Osmani argues AI is creating a 5-7x speed-comprehension gap: AI can generate 140-200 lines of code per minute, but humans can only understand 20-40. Every minute AI "saves" you costs 5-7 extra minutes of digestion — cost you wouldn't incur if you had written it yourself.
arXiv:2603.22106 (Margaret Storey et al.) proposes a fuller "triple debt model":
1. Technical Debt: structural problems at the code level 2. Cognitive Debt: erosion of the team's shared understanding of the system 3. Intent Debt: the rationale, goals, and constraints behind code not explicitly recorded
As AI accelerates coding, the latter two debts grow exponentially — because the code generator (AI) leaves no thinking traces, and the person using AI never went through the full thought process.
Another study, arXiv:2602.20206 (Mitigating Epistemic Debt in Generative AI-Scaffolded Novice Programming), shows: among 78 novice programmers, the unrestricted-AI group had a 77% failure rate, while a "scaffolded" guidance group failed only 39%. The problem is not AI itself, but how it is used.
5. A Three-Tier Model of AI Use: Where Are You?
Tier 1: Copy-Paste (Danger Zone)
Tier 2: Concept Exploration (Safe Zone)
Tier 3: Think First, Then Ask (Optimal Zone)
This isn't "don't use AI." It's that how you use AI determines how good you'll be in five years.
6. From AF447 to Cursor: The Automation Paradox
Aviation lived through all of this before. In the 2009 Air France AF447 crash, degraded manual flying skills after autopilot disconnection contributed directly to 228 deaths. When automation long replaces humans on core tasks, "muscle memory" atrophies — not because people got lazy, but because the brain rewired itself.
Programming is experiencing the same. Cursor, Claude Code, and GitHub Copilot are not bad tools. They are extremely efficient tools — and that efficiency itself is the problem.
When you let AI write 80% of your code every day, your brain slowly, invisibly, packs away those neural networks like unused tools. The catch: those "tools" are your core competency as an engineer.
7. Refusing Cognitive Surrender: Five Practical Principles
1. Write before asking: work independently for at least 15-20 minutes before considering AI. MIT research confirms this ordering changes brain activity patterns. 2. Explain to the AI: before asking for help, articulate your reasoning and expectations in natural language. This forces System 2 (slow thinking) and avoids being "anchored" by fluent output. 3. Review line by line: never use "accept all." In Anthropic's experiment, the developers with the least comprehension decline were those who reviewed AI suggestions line by line. 4. Regular AI-free days: at least one day per week coding without AI. It's "manual flight training" for your brain, keeping core circuits active. 5. Write "cognitive receipts": after each AI use, spend 2 minutes noting "what AI did" and "why I agreed/modified." This is the minimal viable practice against cognitive debt.
8. Conclusion: Tools Are Neutral, But Usage Is Not
AI coding tools carry no original sin. The problem is that when a tool's design philosophy is "make you faster" rather than "make you stronger," the user's cognitive ability becomes the hidden cost.
Both this post and the author's earlier piece on the Anthropic experiment share the same core message: speed is not ability. Efficiency is not growth.
In the AI era, the most dangerous skill atrophy is not "can't write code" — it's "thinking you can write code."
Five years from now, what separates excellent engineers from average ones won't be how much AI they used, but whether they retained high-level thinking ability after AI took over low-level tasks.
The choice is yours: be an engineer who commands AI, or an operator controlled by it.
---