private beta · waitlist open

you don't know what your codebase does anymore, do you.

You let the agent take on more of the work. It kept shipping. Your mental model of the system stayed where it was — and the code didn't. Now you can read the files but not the system, and you can't tell the agent what to fix without re-deriving the architecture first.

No spam. We'll ping you when there's something worth showing — early access goes to the waitlist first.
You're on the list. We'll ping you when there's something worth seeing.
A small architecture graph with one node — auth — glowing coral, indicating recent activity.
the moment

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 gap

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
what it is

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.

// visual

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.

// changelog

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.

// time slider

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.

outcomes

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.

prototype

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 →
questions

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.

waitlist

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.

One email when there's something to show. Then nothing until we have actual users to talk about.
You're on the list. We'll ping you when there's something worth seeing.