covateYou already generate the raw material for a learning record every day: every diff you merge contains a decision, a trade-off, often a bug you just fixed and a lesson you just paid for. The problem was never producing the material — it’s that capturing it by hand doesn’t survive contact with a full schedule. A learning ledger flips the direction: instead of you writing down what you learned, the work tells you what to review.
Five levels of keeping the record
- 01
Level 0: nothing (the default, and the leak)
Most developers record nothing. Every hard-won lesson — why the race condition happened, what the weird regex does, which fix actually worked — lives in working memory for a week and then dissolves. A year later you re-solve the same problems in the same codebase. This is the leak a ledger exists to plug.
- 02
Level 1: commit-message discipline
The lightest real practice: when you commit, add a line about what the change taught you ('learned: retries without idempotency keys double-charge'). It costs a minute, stays attached to the exact code, and git history becomes readable as a learning record. The weakness: it's easy to skip exactly when you're busiest, and it records lessons only at commit granularity.
- 03
Level 2: a hand-kept journal
A markdown file or notebook with dated entries: what I worked on, what confused me, what clicked. Works, and many strong developers swear by it — but the failure mode is well documented: entries thin out after two weeks, because journaling competes with shipping for the same attention. If it survives for you, keep it. If it hasn't, the fix isn't more willpower — it's removing the human from the transcription step.
- 04
Level 3: derive the ledger from the work itself
The sustainable pattern: let tooling generate the record from your actual coding sessions, so the ledger writes itself while you work. That's what Covate does — its MCP watches what changes in your codebase and turns each real diff into a short quiz; your answers (right or wrong) are the ledger's raw material, timestamped and attached to the code that taught you. No end-of-day transcription, nothing to remember to write down.
- 05
What the ledger should show you
Three things make a ledger worth keeping: the sessions themselves (what you worked on and when), a running accuracy number (is understanding improving or drifting?), and — most valuable — the topics you answer worst. That last list converts vague 'I should get better at this stuff' into a concrete, self-updating study queue. Without it, review time goes to whatever you already enjoy.
The review ritual that makes it pay off
A ledger earns its keep in one weekly ten-minute ritual. Open it and ask three questions: What did I answer wrong this week? Which topics keep recurring across sessions? Is my running accuracy moving? Whatever tops the wrong-answers list is the next study session — not a random tutorial, but the exact gap your own code exposed. This is ordinary spaced repetition applied to your own work; the science and the scheduling behind it are covered in spaced repetition for developers. And since the entries come from real diffs, the ledger doubles as a map of your codebase history — the same territory covered from the reading side in how to learn a new codebase fast.
A ledger that writes itself — with Covate
Covate is the level-3 approach, built in. The open-source MCP runs locally alongside your AI coding assistant (Claude, Cursor, Copilot and others), turns your real code changes into short, targeted quizzes with its learning_session tool, and keeps project-level debug memory with debug_search — no account required. Sign in with GitHub at covate.org, reveal your sync token in the dashboard, and run python -m covate.platform_sync from a project to push sessions into the free learning ledger — every session with its score, your running accuracy, and the topics you answer worst. Nothing to buy, on either half.
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 a learning ledger?
A running, per-session record of what your coding actually taught you: what changed, why, what you understood easily, what you got wrong, and what keeps coming back as a weak spot. Unlike a journal you write at the end of the day, a good ledger is derived from the work itself — diffs, quiz answers, review notes — so it captures lessons at the moment they happen instead of from memory later. The point isn't the archive; it's that the weak-topic list and accuracy trend tell you exactly where to spend your next study hour.
How do I keep a learning ledger without it becoming another abandoned habit?
Don't hand-write it — derive it. Manually kept journals die within weeks because transcription competes with shipping. The approach that survives is automation at the moment of learning: Covate's open-source MCP watches what changes in your codebase and turns each real diff into a short quiz, blocking further generation until you answer. Those quiz sessions are your ledger entries, captured while the context is fresh, with zero end-of-day writing. You review the record; the tool keeps it.
How does Covate's ledger work, concretely?
Two halves, both free. Locally: the MIT-licensed MCP server plugs into your AI coding assistant (Claude, Cursor, Copilot and others) and exposes a learning_session tool that generates blocking, interactive quizzes from your recent code changes — no account required. In the cloud: sign in with GitHub at covate.org/dashboard, reveal your sync token, and run COVATE_SYNC_URL=https://covate.org COVATE_SYNC_TOKEN=<token> python -m covate.platform_sync from a project to push local sessions up. The ledger then shows each synced session with its score, totals, your running accuracy, and the topics you answer worst. You can reveal or rotate the sync token at any time.
Does the learning ledger cost anything?
No. The MCP server is MIT-licensed open source and runs locally; the ledger on covate.org is free — sign in with GitHub, nothing to buy. There is no paid tier, subscription or checkout anywhere on the site.
What's the difference between a learning ledger and a work journal?
A journal narrates ('today I worked on the billing refactor and it went okay'); a ledger measures. Because ledger entries are generated from real diffs and quiz answers rather than written from memory, they're timestamped, tied to specific code, and roll up into signals a journal can't give you: running accuracy over time, and the ranked list of topics you keep getting wrong. A journal says you feel stuck on concurrency; a ledger says you've missed concurrency questions in five of the last eight sessions — which is a study plan, not a mood.
Related