A number that can go down.
Coverage is measured per area of your system, and it has two parts that are never added together: what your history implies about who was involved there, and what somebody has actually explained. Both mean current with what shipped — so when your agents ship into an area, it drops again, for everyone, and areas nobody has touched in months fade slowly. That’s what keeps there being something worth asking on a team that ships every day.
Which means it does not start at zero. The first part is inferred from your own git and pull-request history — who committed in the deliberation that produced each decision, and who reviewed it — so a real picture exists on day one with nobody having answered anything. That part is capped at half, deliberately: having worked in an area is not the same as understanding it, and no amount of committing can buy the top half. Only explaining something goes past 50%.
An area where nothing was ever recorded shows as nothing recorded — not as 0%. Rendering “nobody understands this” when the truth is “nobody ever wrote anything down here” would make the whole number worthless.
team · acme/platform
Causal only. Never trivia.
Every question comes from a real decision in your repo — the reasoning your agents record as they work, and the arguments your team already leaves in pull requests and reviews. Structure is shown in the teaching step, never asked: recalling which service writes to which table proves nothing. What gets asked is the part you can’t look up — why it was built this way, and what breaks if you change it.
- Written for the non-author — a newcomer, someone in another service, or you in three weeks.
- Never about general technology. “How does Postgres RLS work” is trivia anyone can generate.
- Never about a decision your team already reversed.
- Generated when a question is first needed, then cached — nothing runs on every merge.
Your repo is copied into a sandbox, read for structure, then the sandbox is destroyed. Source never reaches the database.
A teammate wants to cache cloned repos for 24 hours to speed up re-ingest. What does that cost you?
the sandbox isn’t a speed choice — it’s the claim the product is sold on
The map underneath it all.
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. What it keeps is the shape: the modules become nodes, the dependencies between them become edges. External services (Stripe, your queue) show up dashed, so the boundary of your system is obvious at a glance.
- Nodes are the real subsystems in your repo, not a diagram someone drew.
- Edges are the dependencies that actually exist between them.
- Every node carries the decisions, tradeoffs and risks that touch it.
- Read-only, one repo at a time, revoke anytime — private repos stay private.
Rewind the whole system.
The map rebuilds on every merge to your main branch, and every build is kept. Drag the time slider and the diagram becomes what your system looked like then — modules appear and disappear, edges form, and each decision, tradeoff and risk snaps to the moment it entered the codebase.
So you don't just see what your system is — you see how it got there: when a module showed up, when a risk was introduced, when a tradeoff was quietly accepted. It never drifts, because it's rebuilt from what actually shipped, not from a doc someone wrote six months ago.
The why, pinned to the map.
The map is the where; the insights are the why. Backthread reads your agent sessions and git history — commits, PRs, reviews, and the issues linked to your work — and its plugin strips code and command output on your own machine, sending the plain-English reasoning plus a little anchoring metadata — the file paths the session touched, the branch and the commit — never file contents. What leaves is listed in full on /security. One pass turns all of it into decisions, accepted tradeoffs and potential risks — ranked, deduplicated, each with its rationale — and pins each one to the module it touches.
- Decisions — the choices your agent made, and why.
- Tradeoffs — what was accepted to get there, and the cost.
- Risks — what was left behind that's worth a second look.
what leaves your machine, and what we store, is on /security →
Some questions are still wrong.
Every one passes a mechanical filter and an adversarial judge before it reaches anybody, and most don’t survive. Some still do. That’s why I disagree and Bad question sit next to the answer, cost nothing, and are the only signal we tune on. If we ever have to choose between asking more and asking well, we ask less.
Bad question kills a question for the whole repo so it never comes back for anybody — and that record includes who flagged it. It is a fact about the question rather than about the person, but your name is on it, and you should know that before you use it.
See it on your own repo.
One command builds your real map and its decision log, free for 14 days. Coverage is there from your history on the first build, before anyone is asked anything.