“You can outsource your thinking, but you can’t outsource your understanding.” @kache · quoted by Andrej Karpathy, 28:10 →

Your team understands
the codebase your agents built.

Backthread keeps the reasoning behind every change your agents ship and turns it into something your engineers actually want to learn from — so they onboard faster, make better calls together, and you can see what your team really knows.

works with Claude Code, Cursor and Codex — across every repo in your system

coverage acme · 14 repos 9 engineers · system 55%
storefront74%catalogauth81%inventory63%payments34%queue22%
payments — 34%. Only one person.
what it does
01 / the system, over time

System diagram with time travel

web mobile orders auth billing

Every service across every repo, drawn as one system — and a slider to pull it back to any week you like.

02 / the risky calls

What your agents accepted.

orders · last 30 days

trade-off A provider outage stalls the queueretries were removed after double-charging

assumption Webhooks always arrive in ordernever checked against the provider

The trade-offs and assumptions accepted along the way — taken from the agent’s own reasoning, not guessed from the diff.

03 / who owns what

Who you can ask.

auth billing orders billing · one person can answer

Owners and authors on the same picture, so “ask whoever knows” has a name attached.

04 / the lesson

A question while you wait.

✻ working… ▍ while that runs — why does checkout put orders on a queue instead of billing them straight away? › _

It arrives in the terminal while the agent is thinking — time your engineer is already spending. Nothing blocks them.

05 / or in the browser

The longer sitting.

the payment provider goes down. what happens to an order placed now? it waits on the queue the customer gets an error

Same lesson on the platform — pick the answer you’d give a colleague, and see the reasoning either way.

06 / coverage rises

Answer, and the coverage rises

queue billing orders

One number per area, and it only moves when a person can actually answer for that part.

read how it works, in detail →
what you get

Onboarding time

Days until a new hire ships a safe change to a service they have never seen. They start from the map and the reasoning behind it, not a tour and a Slack thread.

Single-owner areas

How many parts of your system exactly one person can explain. You get the count on day one, and it falls as more people can answer for each area.

Review depth on agent PRs

Time in review and the share merged without a real read. Reviewers who understand the change stop approving architecture nobody is holding.

Decisions that reach you

Calls spanning several services currently route through the two people who hold the whole picture. That queue is a number, and it shortens as more people qualify.

Comprehension time

Engineers spend most of their week working out what code does. It is the largest line in your budget that nothing currently measures.

Coverage — the new one

What share of your system your team can actually explain, area by area. Nobody has been able to see this before, and it is the number the rest hang off.

where these numbers come from →
demo

See it on a real codebase.

An open-source system, read end to end — the map, the reasoning behind each change, and the coverage on top of both.

security

Your code stays yours.

Nothing leaves unredacted

Secrets are stripped on your own machine before anything is sent. The client is open source — read it.

We never store your source

Analysis runs in a sandbox that is destroyed when it finishes. What we keep is the map and the reasoning.

Read-only, revocable

A GitHub App with read access you can withdraw at any time. Private repos stay private.

the full security page →
install

One command. Any agent.

Connect your repos once. Your team’s next session starts feeding the map.

$ npx backthread ✓ signed in as you@acme.dev ✓ connected acme · 14 repos ✓ capture installed — claude code, cursor, codex → your map: app.backthread.dev/acme
not in a terminal? start in your browser →
pricing

$25 per seat. Free for 14 days.

Pro
$25per seat / month
  • everything on, from day one
  • one repository included, $10 for each one after
  • the trial clock starts at your first build, not at signup
  • no card to start
Start free →
questions

The ones we actually get.

Why not just ask Claude when I need to know?

Because you have to know what to ask, and whether the answer is right. Asking helps the person who already understands the system. It can’t hand that understanding to someone who doesn’t.

Andrej Karpathy — Sequoia AI Ascent 2026
“I am becoming the bottleneck of even knowing what we are trying to build.” · 28:10 →

Do developers even need to understand everything now?

No — and we don’t claim they do. The agent handles the line-by-line. What can’t be handed over is the shape of the thing: what it’s for, how the parts connect, what breaks when you move one.

Matt Pocock — software fundamentals matter more than ever
“AI is a tactical programmer. You need someone thinking on the strategic level — that’s you.” · 17:23 →

Is there any evidence behind those numbers?

For the mechanism, yes; for our effect on your org, not yet — we are too young to have that, and we will not invent it.

Shared understanding really does change how a team performs. A meta-analysis of 231 correlations from 65 independent studies found team cognition positively related to team behavioural process (ρ=.43) and to team performance (ρ=.38). DeChurch & Mesmer-Magnus, J. Applied Psychology, 2010

Reviewers miss things because they do not understand the change. Microsoft’s study of modern code review — 17 developers observed, 570 comments classified, 165 managers and 873 programmers surveyed — found that finding defects is the top-ranked motivation, yet only 14% of comments concerned defects, and those mostly addressed micro-level and superficial concerns. Understanding the change and its rationale emerged as reviewers’ clearest challenge. Bacchelli & Bird, ICSE 2013

Comprehension is most of the job. An instrumented field study of 79 professional developers across 7 industrial projects — 3,244 monitored hours — put program comprehension at about 58% of developers’ time at the keyboard. Xia, Bao, Lo, Xing, Hassan & Li, IEEE Trans. Software Engineering, 2018

Onboarding benchmarks do not measure understanding. The current industry figure is 33 days to a tenth merged PR — and its authors state plainly that it says nothing about the depth of understanding new hires have. DX Engineering Enablement benchmark, 2026

One number we deliberately do not print: that a defect costs 100× more to fix in production. It traces through a textbook to 1981 course notes nobody has produced. Separately, the largest study on record — 171 projects — found no evidence for the delayed-issue effect. Bossavit, The Leprechauns of Software Engineering · Menzies et al., Empirical Software Engineering, 2017

Does using an agent really cost my engineers understanding?

It depends entirely on how they use it, and that is the whole design of this product. In a randomised trial (n=52), developers who used AI to learn a new library scored 50% on a comprehension quiz, against 67% for those who wrote the code themselves. Among the AI users, the authors observed — without claiming causation — that heavy delegation clustered below 40% while conceptual questioning clustered at 65% or above. Shen & Tamkin, Anthropic, 2026

The psychological name for it is cognitive offloading, and it is well established. “Brain rot” is the popular name for it; the phrase has been applied to social media users and even to AI models, but not yet to engineers — though the phenomenon is being studied under other names.

In a 2025 randomised trial, developers believed AI made them 20% faster while measurement showed them 19% slower (n=16) — a result METR has since marked historical. Self-report from your team is not evidence about your team. Becker et al., METR, 2025

Won’t this slow my engineers down?

It uses the time they’re already losing — the pause while the agent works. Nothing blocks them.

How is this different from documentation?

Docs describe the system to whoever opens them, and nobody opens them.

There is a newer problem underneath that. Documentation is increasingly written for agents. Which means the reasoning behind your system is now addressed to a machine, and there is no longer anyone on the human end of it.

This puts the question in front of a person instead, and tells you what came back.

We already write our reasoning into the repo.

Good — that’s the raw material, and it makes us better. But a file being there isn’t the same as a person having read it. That gap is the whole product.

Find out what your team knows.

Connect your repos. The first map takes a few minutes, and it’s free for two weeks.