Progressive disclosure of your codebase's how-it-works.
A visual map of your system, with the why behind every change tucked into a hover. Top-level shows the architecture; hover any module for its full changelog.
A real diagram
The thing you'd sketch on a whiteboard, if you had the headspace. Auto-built from your PRs.
The why, not the diff
Every commit adds a sentence to its module's history — what changed and why. Skip the PR archaeology.
Scrub the architecture
Drag the playhead anywhere in your repo's history. See what the system looked like then. For when "it used to work" is the only clue you've got.
Clew tells you what to look at — not just where to look.
You don't need to read every PR — only the ones that change how the system works. Loose ends surfaces those: architecture moves, default choices, quiet tradeoffs the agent ships while you're looking the other way.
What you actually stop doing.
Not capabilities. Habits you can drop when the codebase explains itself again.
Stop reading every PR.
The changelog already says what each commit changed and why. Skim if you want. 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. Clew 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.
There's a working one. Go poke it.
Not screenshots — it's running. Hover any module for its changelog, drag the time slider to scrub history, click a loose end to see why the agent did what it did.
9-module graph, hover-changelog, draggable time slider snapped to commits. The full thing auto-builds from your actual repo.
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. Clew 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 Clew 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. Clew 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. Clew 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 need commit metadata and diffs to build the changelog. We don't permanently store source. Full security writeup ships before the public beta; short version is roughly the same posture as Sentry or Linear. If your org has a hard rule against any third-party reading code, Clew can't help you yet.
Who's building this?
Solo founder so far, building it in the open. I've been heavily delegating to the same agents Clew is built for — which is how I noticed the problem. There's a working prototype at app.useclew.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.