Your AI never onboarded to your codebase

It was never really amnesia

When a new engineer joins, we don't expect a correct answer on day one. We expect them to onboard — read the code, trace a few flows, ask the dumb questions — until they carry a working picture of how the whole thing fits together. A few weeks later they're fast, not because they memorized a million lines, but because they hold a compressed model of the system in their head.

We do this for every person we hire. Why have we never done it for our agents?

Every session it starts cold — opens a file, greps around, reconstructs just enough to answer the question in front of it, then throws that understanding away. Next session, next teammate, next tool: from scratch. It isn't amnesiac. It just never onboarded.

Everyone's hit the same wall

The field spent the last year converging on one point: the model is no longer the bottleneck — context is. Specifically, comprehension of your system, which is what separates a useful answer from a confidently wrong one. Anthropic's own guide to Claude Code in large codebases is blunt: give an agent too little context and you leave it "to navigate blind."

So we've all reached for the same patch — the CLAUDE.md file: a short brief of pointers and gotchas the agent reads each session (you write it, or a tool drafts it for you). Right instinct. But one page is its ceiling. It's meant to stay skimmable — "pointers and critical gotchas only; everything else drifts into noise" — so it never holds how the system actually works, and one file can't carry the comprehension of a large, multi-repo codebase. As that guide puts it, without the work "knowledge will stay tribal."

Reading live helps — but it has no map

The other half of the patch is letting the agent read code live, in the moment — what Cursor and Claude Code do well. Always current; no stale index between the agent and the truth. But one file at a time, with no map, it can take a wrong turn and never know it — answering from the fragment it opened, not from how the parts connect. Live reading gives you the current detail; it's a poor way to get comprehension. It needs a map to read against.

So we automated the onboarding

That's Peek. Point it at your repos once, and offline it reads everything bottom-up — file, then folder, then the system as a whole — into a layered map of how it all connects. Think of it as what CLAUDE.md reaches for, taken all the way: not one skimmable page but a deep map with a senior engineer's comprehension, generated from the code and rebuilt as it changes. Because the map is hierarchical, it scales without limit — a fifty-repo platform onboards like a small service, since an agent pulls only the summary it needs.

Then, online, a team of agents reasons over that map, dropping into live code for the exact detail when it needs it. The map gives understanding; the live reads keep it honest. Ask in a chat window, or call Peek from Cursor or Claude Code over MCP — the same shared map, whichever tool you're in. And because it's shared, it isn't priced per seat: the first person to index a repo pays, everyone else reuses it.

So "what happens when a webhook comes in?" comes back as the real path — the route that receives it, the handler that processes it, the row it writes — with the files behind each step. Across services, not within one file.

What it isn't yet

We'd rather be honest than oversell. The answers are good — in our own eval harness they come back faithful and complete, reasoning across the whole system instead of guessing from a fragment. What we're still working on is speed: a deep cross-system question takes real time today, because the agents actually do the research instead of pattern-matching to something plausible. We're cutting that down — but given the choice, we'd rather be slow and right than fast and confidently wrong.

Two engineers, no investors

We're two engineers, and we're not taking outside funding — not now, not later. It's deliberate: it decides who we answer to. We've seen the other path — tools that start out for individual developers and small teams, then pull the ladder up. Sourcegraph's Cody is the clearest case: it killed its free and pro tiers and went enterprise-only. Funding makes that almost inevitable; the math points at big contracts, not at you.

We're going the other way: pay-as-you-go, no seats, a free tier we actually want you to use, and one goal — the most value per dollar for the people doing the work. Every email to hello@codepeekr.dev gets a reply from us.

Where this goes

Comprehension of a system shouldn't live in one senior engineer's head, thin out into a file that goes stale, or get rebuilt from scratch by every tool every morning. It should be onboarded once and shared — by the people on the team, and the AI they work alongside.

That's what we're building.

— The Peek Team