Three ways to keep the thread.
AI writes most of the code. You can outsource the thinking, but not the understanding.
Ask it, in plain English
Ask "how does login work?" in your agent. You get a short answer, with links to the decisions behind it. No grep, no re-reading files.
Every decision, written down
Your agent makes dozens of decisions a day. Backthread records each one and why, and flags the ones you never approved.
The whole system, on one map
A live map, built from your code. Click a decision to see where it landed. Hover any box for its history. Drag the slider back in time.
Ask how it works.
A high-level view of every decision, in the browser or in your agent via MCP. You get deterministic answers about how things work.
The "why" isn't in your code. Stop making your agent read all of it.
A "how does X work?" used to cost your agent thousands of tokens of reading. The answer isn't even in the code. Backthread returns it in one call.
Everyone pulls their own thread. Backthread holds the whole one.
On a team, no one sees every decision. Your teammates' agents ship code you never reviewed, and the reason for a change is never in the diff. Backthread shows the why to everyone.
See why any agent did anything
Every decision, from anyone's agent, on one shared map with the why attached. Onboarding, on-call, or reviewing a PR: the reason is right there, not stuck in someone else's session.
Read the decisions, not every line
A red dot marks the decisions no one approved. Reviewers focus on the few that change the architecture, instead of rubber-stamping PRs no one fully read.
A weekly email digest
An email of what your team's agents decided each week, so no one has to rebuild the picture from PRs.
"Comprehension debt is the growing gap between how much code exists in your system and how much of it any human being genuinely understands."
"If an LLM wrote every line of your code, but you've reviewed, tested and understood it all, that's not vibe coding, that's software development."
"You fully give in to the vibes, embrace exponentials, and forget that the code even exists."
What you stop doing.
Stop digging through old code.
Every bug used to start the same way: what is this file, why is it like this? Now it starts with an answer.
Stop reading every PR to stay in the loop.
Backthread flags the decisions that matter. Read the few that count, skip the rest.
Stop relearning your own system.
It was recorded the whole time. You just had nowhere to see it.
There's a live demo. Go try it.
Not screenshots. It's live. Click a decision to light up the code it touches, read the why, drag the slider through history. Built from a real repo.
Open the demo →One command. Any agent.
See it on your own repo, free. Pick where you code:
/plugin marketplace add backthread/backthread/plugin install backthread@backthreadThen run /backthread:start. Same setup, built into Claude Code.
npx backthread install --agent codexnpx backthread install --agent cursornpx backthread install --agent geminiFree to see it. Cheap to keep it.
Build your repo once, free. After that, a flat price per seat with a monthly allowance included. Go over it and you pay a clear per-unit rate.
Free
A real build of your own repo. Once.
- One full build of one repo
- Your real map + decision log
- Ask it anything, once it's built
Solo
For when you are the whole eng team.
- 1 seat · 1 repo
- Rebuilds itself on every merge to main
- Full history + time slider
- Ask it anything, any time
Team
For the 2–30 people losing the thread together.
- Seats you add and drop, GitHub-style
- Everyone's decisions on one shared map
- Shared answers across the whole team
- 300 rebuilds + 500 sessions per seat
Extra repos: +$10/mo each; you get one to start. Over your monthly limit? $0.20 per rebuild, $5 per 1,000 sessions. Most people never get close.
Your code stays yours.
Backthread connects to two things: your GitHub repo, to build the map, and your coding agent, to capture the why. 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. Access is read-only, one repo at a time, and you can turn it off in GitHub anytime. Private repos stay private.
Reads your sessions to capture the why
The plugin reads your agent's chat on your own machine, removes the code and command output, and sends only the plain-English "why." Your code itself is never sent. It's open source, so you can check it →
The full list of what leaves your machine, what we store, and every sub-processor is on /security.
Things you might be wondering.
Can I really just ask it questions?
Yes. Ask "how does X work?" or "why is it built like this?" in your agent. You get a short answer in plain language, with links to the decisions behind it. It uses the full history, so the answer is current.
I'm shipping fast right now. Do I need this?
Probably sooner than you think. The pain isn't loud on day one. It's slowly losing the ability to say what your system does without re-reading it. Most people hit it around week three of heavy AI use: every bug needs a research session first. Backthread keeps the picture current, so you don't rebuild it by hand.
How is this different from a code-review tool?
Code review shows what changed in one PR. Backthread shows what your whole system is now, what it was a month ago, and why it changed. Different question, above the diff.
Do you read or store my code?
We copy your repo into an isolated sandbox, read it, save only the map and decisions, then delete the sandbox. Your code never lands in our database, logs, or backups. The plugin also reads your agent's transcripts, but removes the code and command output on your machine first. Full details on /security.
Who's building this?
Solo founder so far, building in the open. I use the same agents Backthread is built for, which is how I found the problem. It's live and free to start at app.backthread.dev. I'm looking for the first people to run it on a real codebase and tell me what's missing.
Stop re-reading
your own code.
Point Backthread at your repo. Ask it anything, see every decision, read the why behind each one.