What Backthread actually does.
Your agents write most of the code now, and nobody can tell you how much of it your team still understands. Backthread keeps the reasoning behind every change — the decisions your agents made, the tradeoffs they accepted, the risks they left — and uses it to ask your engineers short, specific questions about the system they work in. What they can answer for is your coverage, drawn on a live map that rebuilds on every merge. Five minutes a day each, and it goes up.
How coverage is measured →- Stop finding out at 3am that nobody knew how it worked.
- Stop guessing whether the person on call can explain the system.
- Stop discovering the bus factor the week someone resigns.
Every area, and who can explain it.
Every point on this map was earned by somebody answering for that area — which is exactly why it means something. Areas only one person can answer for are flagged: that’s your bus factor, visible before it’s an incident.
Coverage means current with what shipped: when your agents ship into an area, its coverage drops again. And an area nobody ever wrote anything about reads as nothing recorded — never as a team that doesn’t understand it. A number that lies once is never trusted again.
Five minutes a day, per engineer.
Coverage doesn’t rise by reading documentation nobody opens. It rises when someone answers for a part of the system — so Backthread runs a short lesson, in the browser or the terminal.
Two sentences on one part.
How that piece works, and why. Structure is shown, never asked — recall proves nothing.
Then a few questions.
Causal only: what breaks if you change it. Got it or Not yet — no score is kept.
Coverage rises.
That area brightens and the system number follows. Ship into it again and it fades.
Why your team will actually do it.
The number only moves if people answer, so the ask has to be small and the reason has to be theirs — not yours. Here’s the version you can say out loud in standup:
Five minutes a day, so you’re not the only one who can fix payments at 3am. It runs in your terminal. Nobody sees your score — not me, not anyone.
the whole internal pitchThe rota is the reason
They get paged for services they didn’t write and review PRs in areas they’ve never opened. Five minutes now beats a cold start at 3am. It’s already the deal — this just makes it survivable.
There’s nothing to leak
No per-person view exists to be granted, exported or asked for. That’s a design constraint, not a setting you promise not to flip — which is why the promise is worth anything.
It comes to them
One line in Claude Code or Cursor, next to the work they’re already doing. No course, no meeting, no extra tab, no calendar invite anybody resents.
The honest cost: five minutes per engineer per day, and nothing is mandatory. There’s no attendance report — the only sign anyone took part is the map moving, which is the only sign that matters.
You get the map. Not a report on people.
Deliberate, and worth understanding before you roll this out: there is no per-person view, for anyone. That constraint is why your engineers will actually use it.
The system
Coverage per area, how it moved this week, and how many people can explain each part — the count, never the names. One-person areas are flagged as risk. That’s the number you can act on: staff it, pair on it, or write it down.
Their own answers
Each person’s own coverage, their streak, and what they got wrong stays with them. No admin view, no export, no leaderboard. Someone leaves the team and the coverage they contributed is deleted — so the number drops, honestly.
No points, no levels, no leagues — every question costs a real model call, so points would only pay people to click through. The full model is on /how-it-works →
See it on a real codebase.
A live demo runs on a real repo. Open the map, take a lesson on a system you’ve never seen, and read the decision, tradeoff or risk behind the answer.
Open the live demo →Your code stays yours.
Backthread connects to two things — your GitHub repo, to build the map, and your team’s coding agents, to capture the reasoning. Here’s what each one does with your code.
Reads your code to build the map
The GitHub App copies your repo into a temporary sandbox, reads its structure, and deletes it. Your code is never saved to our database. Read-only, one repo at a time, revoke anytime. Private repos stay private.
Keeps the reasoning, not the code
The plugin works on each engineer’s own machine: it strips the code and command output before anything leaves, and sends only the plain-English reasoning behind a change. It’s open source, so you can check it →
From a lesson we keep the answer someone typed, the verdict, and which areas it covered — readable by them and by nobody else, admins included. The full list of what leaves your machine, what we store, and every sub-processor is on /security →
One command. Any agent.
See it on your own repo, free. It connects your repo, installs capture in your agent, and builds your first map.
npx backthreadIn Claude Code, run /backthread:start to set up and /backthread:learn to take a lesson where your engineers already work. Works with Claude Code, Cursor, Codex & Gemini.
Free to close a gap. Cheap to see them all.
Anyone on the team can take a lesson and raise their own coverage on any plan — a habit you have to pay for never forms. What you pay for is the view across the whole team, the history, and the volume.
Free
A real build of your own repo. Once.
- Daily lessons, unlimited
- Your own coverage and streak
- One full build of one repo
- Ask it anything, once it's built
Solo
For when you are the whole eng team.
- 1 seat · 1 repo
- Rebuilds on every merge to main
- Full history + time slider
- Ask it anything, any time
Team
For the 2–30 people losing track together.
- Team coverage on the map
- Bus-factor flags — areas one person deep
- Everyone's decisions on one shared map
- 600 credits per seat, pooled across the account
Extra repos: +$10/mo each; you get one to start. Run low on credits? Top up with a prepaid pack — $5 / $20 / $100 buys 50 / 200 / 1,000 credits, good for 12 months. Most people never touch it.
Things you might be wondering.
Is this like test coverage?
Same idea, different subject: it measures how much of your system your team can still explain, not how many lines a test executed. It’s honest about its limits — an area where nothing was ever recorded shows as nothing recorded, not as 0%, because those are very different problems.
Who does the answering — me, or my engineers?
Your engineers, five minutes at a time. You get the map across the team; each person keeps their own answers. You never receive a report on an individual — that’s the trade that makes people willing to do it at all.
Does everyone have to do this every day?
No, and there’s no attendance report to chase them with. Coverage simply reflects who has answered for what. An area nobody answers for stays thin — which is honest, and usually tells you something about that area rather than about the people.
What if only half the team takes part?
Then you get a real number for half the system instead of a fake number for all of it. Most teams start with whoever is on the on-call rota, because that’s where the reason is most obvious, and it spreads from there.
Can I see how an individual scored?
No. There is no admin view, no export and no per-person breakdown anywhere in the product — it isn’t a permission that can be granted. What you see is system-level: how covered an area is and how many people can explain it. If exactly one can, that shows as a risk on the area; the name is shown only to that person.
Is this gamified corporate training?
No. No points, no levels, no leagues, no leaderboard. Every question is about your codebase specifically — nobody is asked how Postgres row-level security works, because that’s trivia anyone can generate.
What if a question is wrong?
I disagree and Bad question sit next to the answer, cost nothing, and are the signal we tune on. Questions come from your recorded decisions and pass a mechanical filter and an adversarial judge before anyone sees them — but some still get through.
We never wrote our decisions down. Does this work on our repo?
Mostly. The reasoning is already there — your agents record it as they work, and your team leaves it in pull requests and reviews. Backthread keeps it instead of letting it expire. Where nothing was ever recorded, the area reads as nothing recorded rather than pretending anyone is ignorant.
How is this different from a code-review tool or a wiki?
Review checks the lines in one PR; a wiki is stale the day it’s written. Backthread sits above the diff — what the system is now, what changed, and the reasoning behind it — and rebuilds on every merge. And unlike both, it can tell you who still understands it.
Does it work with our agents and repo?
Claude Code, Cursor, Codex and Gemini, on any GitHub repo — public or private. One command — npx backthread — connects your repo, installs capture in your agent, and builds your first map, free.
Who’s building this?
Jevgeni Bogatyrjovlinkedin.com/in/bogatyrjov →
I build with the same coding agents Backthread is made for, and I kept losing the plot on what they’d changed and why. Capturing the reasoning turned out to be the easy half — the hard part is knowing whether anyone still holds it. That’s what coverage is. It’s live today at app.backthread.dev. If your team is delegating real work to agents, I’d like to hear how it holds up on your repo.
Find out what your
team knows.
Point Backthread at your repo. Get the map, the thin spots, and the five minutes a day that fix them.