Understand any codebase.

Open your agent in any repository. In Claude Code, type the command. In Codex, Copilot, Cursor and the rest, ask for it in plain words. Point it at a subfolder to cover one package of a monorepo. The agent says what it is doing at each step, and everything it produces goes into .onramp/. Your code is never modified.

Writes

.onramp/index.html, GUIDE.md, guide.json, scan.json

Needs

Python 3.8+ and nothing else

scan.py takes inventory in seconds, without a model. It reads .gitignore, counts files and lines per language, parses manifests, finds entry points and env vars, and builds an import graph for JS/TS, Python, Go, Rust, Java/Kotlin, C/C++, Ruby and PHP. It also reads git history for churn and a timeline.

Every file then gets an importance score. The score goes up with how many files import it, how often it changed, how big it is and whether execution starts there. Claude reads in that order, so the first hour goes to the files that matter. The maps in the guide are drawn from this graph rather than imagined.

If you use Claude Code and the scan finds its transcripts for the project, the agent asks once whether to use them. If you say yes, sessions.py pairs every file Claude wrote or edited with the prompt that led to it and the explanation Claude gave just before the edit. That becomes evidence for the "how it was built" and "why" chapters. Other agents' histories are not read yet, so git history carries those chapters.

Transcripts are read from your disk and never leave it. Anything that looks like an API key or token is redacted. Claude Code deletes transcripts after about 30 days by default, so older projects lean on git history instead.

The agent reads in a fixed order:

1. the README, CLAUDE.md and docs
2. manifests and config, which say how it installs and runs
3. entry points, then the top of the importance ranking
4. for each important user action, every call from the entry point to storage and back

One rule overrides speed: it never describes a file it has not opened. On large repositories, agents that can start subagents fan out, one per module, writing file cards in parallel, while the main agent traces the flows itself.

The guide is a JSON file of lessons, the stops on your route. Each lesson teaches one idea and records which chapter it belongs to, how essential it is (core, standard or deep), how many minutes it takes and which goals it serves. That metadata is what lets one guide become a 1-hour route or a 1-week route.

Around the lessons sit the structured parts: traced flows, file cards, the stack with primers for newcomers, the data model, build-order milestones, decisions marked documented or inferred, risks and exercises. Every technical sentence carries a citation.

verify.py opens every cited file and checks three things: the file exists, the lines exist, and the quoted text is inside those lines. Each citation ends one of three ways:

• Verified. The text is where the guide says it is.
• Re-anchored. The text is in the file but the line numbers drifted, so the citation moves to where it really is.
• Rejected. The text is nowhere in the file. The agent re-reads the code and rewrites the claim, then runs the check again.

The guide is only built when the check passes. Its badge states how many claims were checked and at which commit.

render.py builds a single HTML page with the guide, the computed maps and the real code behind every citation embedded in it. It opens straight from disk with no server, and works offline apart from fonts, diagrams and syntax colours. It also writes GUIDE.md, the same guide as markdown, for GitHub and for other agents. Render with --public to share it without your local paths.

The guide opens on three questions: how much time you have, what you want to do, and your background. Then it plans your route and draws it as a road.

• Stops start with a one-line summary, then the explanation, a "go deeper" section and a checkpoint question.
• Citations open the real code beside the text, with the cited lines highlighted and links to your editor or GitHub.
• Files shows every file the guide explains, what it depends on and what uses it.
• Map shows the architecture, the computed dependency graph, languages and history.
• Search covers stops, files, ideas and flows. Press Ctrl K.

Prefer a conversation? Ask for the tutor (/onramp tutor in Claude Code). It walks the same route in chat, one stop at a time, and remembers where you stopped.