covateThe case that it does
There's a real mechanism behind the worry, and it's worth taking seriously. Programming skill is built and maintained by two kinds of effort: retrieval (pulling APIs, syntax and patterns out of your own memory) and problem-solving (working out why something breaks and how to fix it). An AI assistant can remove both. When it hands you a working solution before you've tried to recall or reason your way to one, you skip the effort — and it's the effort, not the finished code, that does the learning.
Do that consistently and the skills you've stopped exercising get slower and less reliable, the same way any unused skill does. The insidious part is that nothing feels wrong while it's happening: the AI covers for you, the features ship, the tests pass. The gap only surfaces when you hit a problem the model can't solve, sit an interview, or have to reason through a code review unaided — and realize you've been shipping code you couldn't have written or debugged yourself. That's not a myth; it's ordinary skill decay, and heavy passive AI use is a fast track to it.
The case that it doesn't — and can even reverse it
And yet plenty of developers are getting better with AI, not worse — because the same tool, used actively, is arguably the best learning accelerator programming has ever had. It can explain unfamiliar code line by line, lay out three approaches to a problem with their trade-offs, introduce you to libraries and idioms you'd never have stumbled on, and answer “why” the instant you're curious — while the context is still fresh in your head.
It also lets you take on more ambitious projects than you could alone, and ambitious projects are where real learning happens. The developers who improve with AI treat it like a tireless pair-programming tutor: they read what it writes, ask it why, predict what it'll do before they run it, and use it to go deeper instead of to avoid thinking. Exact same tool, opposite result. The difference isn't the AI — it's the human's posture toward it.
The deciding factor: active vs passive use
So the real question isn't “is AI good or bad for my skills?” It's “am I using it actively or passively?” Passive use — generate, glance, accept, repeat — is the road to decay. Active use — engaging with the code the AI produces while the context is fresh — is the road to getting better. And staying active is cheapest at one specific moment: right after a change is generated. A few concrete habits keep you on the right side:
- Read generated code to explain it, not just to approve it — if you can't say what it does and why, that's the gap to close.
- Before accepting a change, predict what it does and what would break if you altered a line.
- When the AI uses an API or pattern you don't fully know, learn it right then, while the context is fresh.
- Every so often, solve something without the AI, to keep the underlying muscles warm.
None of this means coding slower across the board. It means spending a minute of real attention on the code that just entered your codebase — exactly when learning is cheapest and sticks best. Do that, and AI makes you faster and better instead of trading one for the other.
Stay on the right side — automatically — with Covate
Staying active is simple in theory and easy to forget in practice. Covate makes it automatic. It's a free, open-source MCP tool that plugs into your AI assistant (Claude, Cursor, Copilot and others), watches what actually changes, and turns your real diffs into short, targeted quizzes — blocking further generation until you answer, so you understand each change while the context is fresh instead of passively accepting it. Every session is saved locally, and the free Covate learning ledger takes them from there: sign in with GitHub and every synced session, your running accuracy, and the topics you keep getting wrong are there to review. Nothing to buy.
Free · no card, no waitlist
The MCP is free and open-source (MIT). So is the learning ledger on covate.org — sign in with GitHub, nothing to buy.
How can you check that you actually understood the code?
Five things people do after an AI writes a change, compared on what each one actually proves rather than on how thorough it feels.
| Way to check | What it proves | Stops the AI mid-flow? | Needs another person? | Leaves a record? | Cost |
|---|---|---|---|---|---|
| Read the diff yourself | Nothing you can check later — recognising code reads as understanding it | No | No | No | Free |
| Ask the AI to explain it | That the AI can produce an explanation, not that you followed it | No | No | In the chat log only | Free |
| Human code review on the pull request | A second person's reading — 45% of developers say reviewing and debugging AI code takes longer | No — it happens after the code exists | Yes | Yes, review comments | A reviewer's time |
| Write tests for the change | The behaviour you thought of; AI-written tests can pass tautologically | No | No | Yes, the test suite | Free |
| Answer questions on your own diff (Covate) | Whether you can answer 3 questions about the change you just accepted | Yes — the tool returns HALT_GENERATION until you answer | No | Yes, the learning ledger | Free, MIT |
The 45% figure is from the 2025 Stack Overflow Developer Survey; the Covate row is read from this repository's source, not estimated.
What does the research say about AI-written code?
Four primary sources, each linked below, and every figure quoted from the source rather than summarised second-hand. They disagree with each other in useful ways.
Does AI actually make developers faster?
Not always. In a 2025 randomized controlled trial, 16 experienced open-source developers predicted AI would cut task time by 24% and afterwards believed it had saved 20%. Measured, the same 246 tasks took 19% longer with AI than without. METR, arXiv:2507.09089
Why do other studies show a large speed-up?
Because they measure different work. A 2023 controlled experiment found developers with GitHub Copilot finished a self-contained HTTP-server task 55.8% faster. That is greenfield code; the 2025 trial used mature repositories the developers already knew well. arXiv:2302.06590
How much do developers trust what AI writes?
Less every year. In the 2025 Stack Overflow Developer Survey, 84% of respondents use or plan to use AI tools, up from 76% in 2024 — yet 46% distrust the accuracy of the output against 33% who trust it, and only 3% highly trust it. Favourable sentiment fell from over 70% in 2023 and 2024 to 60%. Stack Overflow, 2025
Where does AI-generated code actually go wrong?
The same survey ranks the frustrations: 66% cite “AI solutions that are almost right, but not quite”, 45% say debugging AI-generated code takes longer, 20% report losing confidence in their own problem-solving, and 16.3% say it is hard to understand how or why the code works.
Is AI-assisted code less secure?
In a Stanford user study, participants with an AI assistant wrote significantly less secure code than those without — and were more likely to believe their code was secure. Read every generated diff that touches input, auth or secrets against the OWASP Top 10 and the CWE Top 25. arXiv:2211.03622
What exactly does Covate install and do?
Everything below is read from the open-source repository, so you can check each number against the code before you install anything.
What does the MCP server actually add?
4 tools: learning_session (quizzes you on recent changes), debug_search and debug_record (a per-project debugging memory), and term_get (concept lookups across 10 domains). It needs Python 3.11+, binds to 127.0.0.1, and is MIT-licensed.
How long does one learning session take?
A session defaults to 3 questions with 4 options each, generated from 7 change-type templates and aimed at 5 focus areas — logic, security, performance, architecture and syntax. The default cap is 10 minutes, configurable from 1 minute to 2 hours.
Where do the sessions end up?
On your machine first: the server keeps the 100 most recent sessions per project, and the quiz UI ships in 3 languages. Signing in with GitHub and running the sync client pushes them into the learning ledger, which is free — there is no paid tier anywhere on this site.
Does it work with my assistant?
If your assistant speaks the Model Context Protocol, yes — Claude, Cursor, Copilot and the rest all load MCP servers the same way, described in the 2025-06-18 specification.
Sources
Every figure on this page comes from one of these, or from the Covate repository itself. Each link was checked on 27 August 2026.
- Model Context Protocol — specification (2025-06-18)The protocol Covate implements. Defines how a tool is exposed to an AI assistant and how a call returns.
- METR — Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer ProductivityRandomized controlled trial, 16 developers, 246 tasks. Source of the 19% slowdown and the 20% / 24% self-estimates.
- Stack Overflow Developer Survey 2025 — AI sectionSource of the 84% adoption, 46% distrust, 66% “almost right” and 45% debugging figures.
- DORA — State of AI-assisted Software Development 2025Google Cloud’s annual study; finds AI amplifies an organisation’s existing strengths and weaknesses rather than replacing them.
- OWASP Top 10The 10 web-application risk categories to read a generated diff against before merging it.
- CWE Top 25 Most Dangerous Software WeaknessesMITRE’s ranked list of the 25 weakness classes that cause the most real damage.
- Git — git-diff documentationThe diff Covate reads is an ordinary git diff; the official flags for narrowing it are here.
FAQ
Does using AI actually make you a worse programmer?
It can, but it isn't guaranteed — and that's the honest answer most hot takes skip. Using an AI assistant makes you a worse programmer when it lets you stop doing the mental work that built your skills in the first place: when you accept code without understanding it, stop practicing recall of APIs and syntax, and stop debugging from first principles because the AI usually fixes it for you. Those are real skills, and like any skill, they decay from disuse. But the same tool used differently can make you a better programmer — a faster feedback loop, an always-available tutor, exposure to patterns you'd never have found alone. The tool is neutral; what decides the outcome is whether you stay an active participant or become a passive one.
Why does relying on AI cause skill decay?
Because skill comes from effortful retrieval and problem-solving, and AI can quietly remove both. When you write code yourself, you're constantly retrieving knowledge from memory (which method, what argument order, how this API behaves) and solving small problems (why doesn't this compile, what's the edge case). Every one of those acts strengthens the underlying skill. When an AI supplies the answer before you've tried to retrieve or reason, you skip the effort — and it's the effort, not the answer, that does the learning. Do that for months and the skills you've stopped exercising get slower and less reliable, even though day-to-day everything feels fine because the AI is covering for you. That's why decay is easy to miss until you hit a problem the AI can't solve, or an interview, or a code review where you have to reason unaided.
Can AI actually make you a better programmer?
Absolutely — used actively, it may be the best learning tool programming has ever had. It can explain unfamiliar code line by line, show you three ways to solve a problem and the trade-offs, introduce you to idioms and libraries you didn't know existed, and answer 'why' the instant you're curious, while the context is fresh. It lets you attempt more ambitious projects than you could alone, and every ambitious project teaches you something. The developers who get better with AI are the ones who treat it as a pair-programming tutor — they read what it writes, ask why, predict what it'll do before running it, and use it to go deeper rather than to avoid thinking. The exact same tool, opposite outcome, based entirely on how it's used.
How do I use AI without losing my skills?
Stay active where it's cheap to stay active: at the moment code is generated. Concretely — read generated code to explain it, not just to approve it; before accepting a change, try to predict what it does and what would break if you altered it; when the AI uses an API or pattern you don't fully know, pause and learn it right then while the context is fresh; and every so often, solve something without the AI to keep the underlying muscles warm. None of this means coding slower across the board — it means spending a minute of active attention on the code that just entered your codebase, which is exactly when learning is cheapest and most durable. The goal is to use AI to move faster AND get better, instead of trading one for the other.
How does Covate help me stay sharp while using AI?
Covate is built for exactly this problem. It's a free, open-source MCP tool that plugs into your AI coding assistant (Claude, Cursor, Copilot and others), watches what actually changes in your codebase, and turns your real diffs into short, targeted quizzes — blocking further generation until you answer, so you're forced to understand each change while the context is fresh instead of passively accepting it. That single habit is the difference between AI making you worse and AI making you better. Every session is saved, and the sync client pushes them into your learning ledger on covate.org — free, no payment — where you can review every past session, your running accuracy, and the topics you keep getting wrong — so 'staying sharp' becomes measurable and automatic rather than a thing you have to remember to do.
Related