It hits around week three.
You delegated the boring stuff to the agent. Then you delegated some of the interesting stuff. Then a bug shows up in a corner of the system you don't remember writing — because you didn't — and the agent has tried five fixes and none of them stuck.
You open the file. It feels foreign. You ask the agent what it does. It tells you. You half-believe it. You start re-deriving the structure from the source because the only documentation that exists is the commit messages, and you stopped reading those around PR #80.
Clew is for that moment. It's the how it works page someone should have been writing while the agent was shipping — except no one was, so we are.
The repo is intact. The understanding isn't.
Everything's still on disk. Nothing's missing from the editor. What's missing is the model of the system that used to live in your head — the part that lets you debug without re-deriving the architecture first.
what you can still see
- the files, the function names
- the latest commit messages
- the PR titles — kind of
- which tests pass today
what's gone from your head
- why this module exists at all
- why this dependency, not the obvious one
- what the agent tried before settling here
- the assumption baked into the data model
Progressive disclosure of your codebase's how it works.
A living visual map of your system — modules, edges, what calls what — with
the why behind every change on main tucked into a hover.
Top-level shows the architecture. Drill down for detail. Hover any module for
its changelog: what changed, why, which agent did it.
A real diagram
The thing you'd sketch on a whiteboard if you still had the headspace to. Auto-maintained as PRs land — no hand-curating, no 48-file AGENTS.md pile.
The why, not the diff
Every commit on main contributes a sentence on what changed and why. Hover a module to see its decision history. Skip the PR archaeology.
Scrub the architecture
Drag the playhead to any point in your repo's history. See what the system looked like then. Useful when "it used to work" is the only clue you have.
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.
Skip the AGENTS.md sprawl.
One auto-maintained "how it works" instead of forty-eight hand-curated context files you keep meaning to deduplicate.
Quit asking the agent what its own code does.
The decision history is on the module. Hover it. Read it once. Move on.
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.
The diagram lives at app.useclew.dev. It's pre-seeded with an
auth subsystem so you can see the shape of the thing — graph,
hover-changelog, time slider, all wired up. Yes, the page is obviously
AI-styled. That's the joke. We're building the product, not the lander.
What you'll see: a 9-module graph with a glowing recently-touched node, a slide-in changelog panel, and a draggable time slider snapped to commits. It's the bones; the full thing auto-builds from your actual repo.
open prototype →Things you might be wondering.
What does the waitlist actually get me?
Early access when there's something to use on your own repo. We're not throwing fake screenshots at people — we'll ping you when you can actually open Clew, point it at a codebase, and see what it shows you.
When is it launching?
When the build catches up to the prototype at app.useclew.dev. Realistically: private beta inside a couple of months, broader access after we've seen what breaks in real codebases.
Which AI coding agents does this work with?
All of them, eventually. Clew reads commit history on main — whatever's shipping commits gets captured. Claude Code, Cursor, Codex, Aider, Devin, Continue, Windsurf, the human writing the occasional hand-edit. We're not coupled to any one agent.
Is this just an AGENTS.md generator with extra steps?
No. AGENTS.md is substrate — context fed back into the agent. Clew is for the human: a visual of what's actually been built, with the decision history per module. Keep your AGENTS.md. Clew sits next to it.
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.
Will there be a free tier?
Yes for solo and small repos. The product earns its keep when a team is stuck in rescue mode and someone is effectively billing engineer-hours to re-derive the architecture by hand. We're not trying to nickel-and-dime indie builders.
Who's building this?
One founder so far, who has been delegating heavily to the same agents Clew is built for. There's a working prototype at app.useclew.dev — that's the bones. The product is being built in public; the waitlist is how we 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 a useful person to have in the first cohort.