covateWhy you forget — the forgetting curve
After you learn something, your memory of it decays over time unless it's reinforced — the classic forgetting curve. For developers this is brutal, because most of what you learn you learn once: you debug a tricky issue, understand it deeply in the moment, and never deliberately revisit it. Months later you hit a similar problem and think “I'm sure I've solved this before” — but the memory is gone. AI assistants make it worse: when the answer is handed to you instantly, you never retrieve it from memory, so it never sticks.
The fix — the spacing effect
The spacing effect is one of the most robust findings in the science of learning: reviews spread out over time build far stronger, longer-lasting memories than the same amount of review crammed together. Spaced repetition operationalizes it — you review a concept at increasing intervals (a day, a few days, a week, a month), each time recalling it just as it starts to fade. Every successful recall consolidates the memory and lengthens the next safe interval. The result: less total effort than cramming, dramatically better retention.
- 01
Capture the concept when you learn it
The moment you figure something out — the async bug, the API gotcha, the trade-off — write it as a question you'd want to answer later, while the context is fresh. Material from your own real work beats generic flashcards every time.
- 02
Recall it, don't re-read it
Reviews only work if you actively retrieve the answer from memory before checking. Re-reading feels productive but barely helps; the effortful recall is what consolidates the memory. Cover the answer, try, then check.
- 03
Space it out — more for what you miss
Review at increasing intervals (a day, a few days, a week, a month), and let the schedule adapt: bring back the concepts you keep missing more often, and stretch the intervals on the ones you've locked in. That's the whole engine.
The catch for developers: hand-building flashcards is tedious, so most people quit — and generic cards are less useful than ones tied to the real situations you hit in your own code. The trick is to anchor the repetition to your actual work, and to make the scheduling automatic.
Repetition material from your real code — with Covate
Covate handles the tedious half of this loop — the material. The free, open-source MCP tool plugs into your AI assistant (Claude, Cursor, Copilot and others), watches your real code changes, and turns them into short quizzes — so the material is your own work, captured the moment you learn it, with no manual flashcards. 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
What is spaced repetition, and why does it work?
Spaced repetition is a study technique where you review something at increasing intervals — a day later, then a few days, then a week, then a month — timed to catch you right before you'd forget it. It works because of two well-established findings in the science of learning. The first is the forgetting curve: after you learn something, your memory of it decays over time unless it's reinforced. The second is the spacing effect: reviews spread out over time produce far stronger, longer-lasting memories than the same amount of review crammed together. Each time you successfully recall something just as it's starting to fade, the memory gets consolidated and the next safe interval gets longer. So instead of re-reading a concept ten times in one afternoon (which feels productive but fades fast), you recall it five times over a month — less total effort, dramatically better retention. It's the most efficient way known to move knowledge into long-term memory.
Why do developers forget so much of what they learn?
Because programming is a firehose and most of what you learn, you learn once and never deliberately revisit. You debug a gnarly async issue, understand it deeply in the moment, and move on — and because you don't hit that exact situation again for months, the forgetting curve quietly erases it. Multiply that across every library quirk, language feature, config option, and pattern you've ever figured out, and you get the familiar experience of solving a problem you're sure you've solved before but can't remember how. AI assistants make this worse, not better: when the AI supplies the answer instantly, you never have to retrieve it from memory, so it never consolidates. The knowledge passes through you without sticking. Spaced repetition is the antidote — it deliberately brings concepts back just as they're fading, so the things you figure out actually accumulate into expertise instead of evaporating.
How do I apply spaced repetition to programming specifically?
The classic tool is a flashcard app (like Anki) where you make cards for things you want to remember and the app schedules reviews for you. That works, but for developers it has a big practical problem: making good cards by hand is tedious, so most people don't keep it up, and generic cards ('what does map() do?') are less useful than cards tied to real situations you hit in your own code. The higher-leverage approach is to anchor the repetition to your actual work: capture the concept at the moment you learn it (the async bug you just fixed, the API you just figured out, the trade-off you just made), phrase it as a question you'd want to answer later, and then get re-quizzed on it on a spaced schedule — more often for the ones you keep missing, less often for the ones you've locked in. The content should come from your real coding, and the scheduling should be automatic; that's what turns 'I learned this once' into 'I actually know this.'
How does Covate do spaced repetition for developers?
Covate is built to make this automatic, from your real code. The free, open-source MCP tool plugs into your AI coding assistant (Claude, Cursor, Copilot and others), watches what actually changes in your codebase, and generates short quizzes from your real diffs — so the material is your own work, captured the moment you learn it, no manual flashcard-making. Those learning sessions are saved, and if you sign in at covate.org with GitHub — free, no payment — the sync client pushes them into a learning ledger: every past session, your running accuracy, and the topics you keep getting wrong, so you know exactly what to bring back for review. Scheduling the repetition is still on you today; the ledger is what tells you what to schedule.
Related