Claude Code Isn't Rereading Your Codebase. Here's Where Your Tokens Actually Go

There's a claim going around that every time you start a Claude Code session, it reads your entire codebase — every file, every function — before you type a word. That's why your plan runs out, the story goes.

It isn't true. And the real answer is more useful than the myth.

What actually loads when you start a session

At startup, Claude Code loads your CLAUDE.md, your tool names, your skill descriptions, and your git status. Not your files. Files get read on demand, only when a task actually needs them.

So where do the tokens go?

Hunting. In a large project, a lot of a session is spent searching for things — grepping for a function, opening a file, finding it's the wrong one, backing out, trying somewhere else. That happens before any real work starts.

And here's the part that compounds: everything the agent reads stays in the conversation. A session that did a lot of searching carries all of it forward on every message after that. You don't pay for the hunt once. You pay for it for the rest of the session.

What Graphify does

Graphify is a free, open-source tool that attacks exactly that problem. You point it at your project once and it maps the whole thing — files, functions, and how they all connect — into a single knowledge graph.

After that, the agent navigates the map instead of searching blind.

It parses code with tree-sitter across roughly 40 languages, which means the code path involves no LLM at all and nothing leaves your machine. It isn't a vector database — there are no embeddings, just a real graph you traverse. And every connection it draws is tagged EXTRACTED, INFERRED, or AMBIGUOUS, so you always know what it found versus what it guessed.

It also isn't limited to code. Point it at a folder holding your source, a few PDFs, some markdown notes and a handful of screenshots, and it maps the relationships across all of them.

About that 70x number

The figure being quoted everywhere is 71.5x fewer tokens per query. It's real, it comes from the project's own benchmark, and it deserves context that almost nobody includes.

That number was measured on a 52-file mixed corpus — code plus five papers plus four images. The project publishes its other results in the same table, and they're more honest than the marketing around them:

• 52 files — 71.5x reduction
• 4 files — 5.4x
• 6 files — roughly 1x, meaning no meaningful savings at all

Their own explanation: token reduction scales with corpus size. A handful of files fits in a context window anyway, so on a small project the value is structural clarity, not compression.

Two more things worth knowing. The benchmark compares against reading all the raw files, which isn't what Claude Code does by default — so the baseline flatters the result. And building the graph over documents and images costs tokens itself, because that pass runs through Claude. Only the code parsing is LLM-free.

None of that makes the tool less useful. It makes the claim honest: on a real project, this cuts a genuine chunk of what you're spending. On six files, it won't.

How to try it

The repo is at github.com/Graphify-Labs/graphify — Apache 2.0, over 110,000 stars, updated constantly.

One gotcha that will trip you up immediately: the install command is pip install graphifyy, with two y's. The single-y package name isn't theirs yet.

From there it runs as a /graphify skill inside Claude Code, and it works with Cursor, Codex and Gemini CLI too. You'll need Python 3.10 or later. Run it once on your project, then ask your agent a question you'd normally have to go find the answer to yourself.

If you want to see what the output looks like before installing anything, the repo ships finished examples — including an interactive graph you can open in a browser and click through.

This is the kind of thing we work through inside Leveraging AI: what these tools actually do, and what they actually cost you.

Come build with us.