Progressive disclosure of your codebase's how-it-works.
The why first, the map underneath. Flows group every decision the agent made; click one and the map lights up where it landed. Hover any module for its full changelog.
The why, from the agent itself
Every decision logged with its rationale, captured as the agent works — not reverse-engineered from diffs after the fact.
Organized by flow
Auth, checkout, sync — click one, see the decisions that built it and where it lives on the map. The words you'd actually use to ask about your system.
A real diagram, in a supporting role
The whiteboard sketch, auto-built — now the canvas that lights up to answer questions. Hover for the changelog; drag the slider to see what the system looked like when "it used to work."
Backthread tells you what to look at — not just where to look.
The agent makes calls all day — algorithm swaps, default choices, quiet tradeoffs. Backthread logs each one with its why, groups it by the flow it shaped, and pins a red dot on the ones you never signed off on.
A GitHub App reads your repo.
Merged PRs become the map and the changelog. Clone, parse, destroy — your source never lands in our database.
A plugin rides along in Claude Code.
When a session ends, it strips the transcript on your machine — code and tool output dropped — and sends only the redacted prose for extraction, at decision time. Not reverse-engineered from diffs later. We keep the decisions, not the conversation.
The exact boundary — what leaves your machine and what doesn't — is spelled out on /security.
What you actually stop doing.
Not capabilities. Habits you can drop when the codebase explains itself again.
Stop reading every PR.
Decisions flag the calls that actually matter; the changelog keeps the receipt for everything else. Read the few that count. Or don't.
Quit treating AGENTS.md like a doc for you.
Forty-eight context files keep the agent on track. That's what they're for. Backthread is the human-readable equivalent — a current map of what's there and why.
Stop re-deriving the structure on a Sunday.
The architecture was getting captured the whole time. You just didn't have anywhere to see it.
Stop doing archaeology before every bugfix.
Every bug used to start with an excavation: what is this file, why is it like this. Now it starts with the decision log.
There's a working one. Go poke it.
Not screenshots — it's running. Click a flow to light up the modules it lives in, open a decision to read the why the agent gave, drag the time slider to scrub history.
Decision log grouped by flow, module graph that lights up on click, hover-changelog, draggable time slider snapped to commits. The full thing auto-builds from your repo and your agent's sessions.
open prototype →Things you might be wondering.
I'm shipping fast right now — do I actually need this?
Probably sooner than you think. The pain isn't dramatic on day one — it's the slow loss of being able to say what your system actually does without re-reading the source. Most people hit it around the third week of agent-heavy delegation: every bug suddenly needs an archaeology session before it can be fixed. Backthread keeps the mental model alive without you having to rebuild it by hand each time.
I just vibe-code — the agent handles everything. Do I need this?
Not yet. You'll know when. The moment you open files the agent wrote and don't recognise them, you'll need either Backthread or a few unplanned hours of forensic re-reading. We'd rather sell you the first one before the second one happens.
I read every PR diff anyway. Isn't this redundant?
Respect — and also: you're paying a velocity tax you might not be tracking. Reading every diff is fine for codebases you mostly wrote. For codebases where 30-70% is the agent's call, you're parsing a lot of noise to find the handful of decisions that actually matter. Backthread flags those decisions directly, so you can read the few that count instead of all of them.
How is this different from a code-review tool?
Code-review tools show you what changed in this PR. Backthread shows you what your system is, accumulated over every PR — and what it was a month ago, and why it changed. Different temporal slice, different question.
Do you read or store my code?
We clone your repo into an isolated sandbox, parse it, write only the derived diagram + changelog to our database, then destroy the sandbox. Your source code never lands in our database, logs, or backups. The long version with the load-bearing detail is on /security. If your org has a hard rule against any third-party reading code, Backthread can't help you yet.
Wait — does the plugin read my Claude Code transcripts?
Yes — and it strips them on your machine before anything leaves it. Every tool call and its output (the parts carrying your source code, file paths, and command output) is dropped; code blocks in the remaining prose become [code redacted]. What survives — natural-language conversation only — is sent to our server, run through the extractor, and discarded: processed in memory, never stored. We keep the derived decisions: a short claim, the why, a date. The honest fine print: on the default path that redacted prose does leave your machine — never source code, never tool output. The full boundary is on /security, and the device token the plugin authenticates with is revocable in one click.
Who's building this?
Solo founder so far, building it in the open. I've been heavily delegating to the same agents Backthread is built for — which is how I noticed the problem. There's a working prototype at app.backthread.dev; the waitlist is how I'll find the first 20 testers.
Get on the list.
We're inviting waitlist signups into a private beta as the build catches up to the prototype. If you've felt any of the above, you're exactly who we're building this for.