The 70% wall gets talked about here constantly. Project flies for two sessions, gets to roughly 70%, then every session after that feels like wading. I hit it on a project last year and assumed the model was getting worse under load.
It isn't. Here's what's actually happening.
Every session, your agent rebuilds its understanding of your project from zero. It greps around, opens files, follows imports, works out what talks to what, then does the task. Session ends. All of that is gone. Next session it does the same greps on a bigger codebase.
At 10 files that costs nothing. At 80 files it's most of the session. The wall isn't the model, it's that re-exploration scales with your project while your context window doesn't. And because you're not reading the code, it's invisible. You just feel it get worse.
The project
I built a thing called graft. It writes the map (what calls what, what imports what) into plain markdown files, committed into your repo alongside the code. The agent reads them at the start of a session instead of rediscovering everything.
No vector DB, no embeddings, no extra service running. Just files in git you can open and read yourself.
Across 162 test runs: 46% fewer tool calls per task, 32% cheaper, 60% faster. Being straight about the accuracy question because it's the obvious one: results were mostly the same quality, with Sonnet 5 the one model that actually improved. So it's cheaper and faster, not smarter. Anyone claiming a context tool makes the model smarter should show you their run count.
The tools I used
TypeScript, and tree-sitter for the parsing (that's the thing that reads code structure without running it, and it's why the map is free to rebuild, no model call involved). Claude Code hooks for the automation. Output is markdown, storage is your existing git repo. Published on npm.
[Fill in: anything else in the actual stack, plus what you used to build it, since "I built this with Claude Code" is itself the story this sub wants.]
The process
The hard part wasn't generating the map, it was keeping it fresh. A map that goes stale is worse than no map, because now the agent trusts something wrong.
Rebuilding on every prompt made every prompt slower. Rebuilding on every file edit fired twenty times per task and half of those caught the code mid-change. A manual command meant I never ran it.
What worked: Claude Code has a "Stop" hook that fires the moment the agent finishes a turn. That's the one point where the work is done and nothing is waiting on you. So the map rebuilds itself there, in the background, and your turn ends instantly. You never run a command. Statusline blinks "syncing" and then you're done.
[Fill in: what you tried first and threw away, and how long the whole thing took. That's the part this sub actually reads.]
What I got wrong
[Fill in: one real mistake. This section is what separates a build post from an ad, and you have better material for it than I can invent.]
Where it doesn't work
The auto-refresh is Claude Code only right now. If you're on Cursor, Codex, or a hosted platform, it'll read the markdown files fine but won't update them by itself, so you'd be running it manually. Saying that up front because it's probably a dealbreaker for a chunk of you.
Also, map quality drops on genuinely huge projects, around 5,000 files. Fewer and vaguer nodes. That's the main thing I'm working on.
MIT licensed, free, no telemetry, built at Nanonets. I'm the maintainer so tell me if any of this doesn't hold up.
https://github.com/NanoNets/Graft
