Cartograph / XSV Development

Same question, twice

● Without a map

01ls .

02ls src

03ls src/components

04glob **/*.ts (1,284 hits, 1,190 in node_modules)

05read package.json

06read src/index.ts

07read src/lib/index.ts

08grep "checkout"

09read src/lib/cart.ts (wrong one)

10read src/routes/checkout.tsx

Ten calls. Tomorrow it does all ten again.

● With a map

01grep "checkout" shop.cartograph.md

02read src/routes/checkout.tsx

Two calls. Also tomorrow.

The file names are made up. The pattern isn't. If you've watched an agent work, you've watched the left side, and you paid for every line of it.

Why I made this

A genius with no short-term memory.

I build most things now with Claude Code sitting next to me. It's brilliant. It also shows up to every session like it's never seen the place before. "Let me start by exploring the project structure." Buddy, you explored it an hour ago. You explored it yesterday. Nothing moved.

It's a contractor who's great with a saw but needs the full house tour every morning. Yes, the kitchen is still there. No, we didn't add a wing overnight. And the tour isn't free: every ls, every glob that wanders into node_modules, every "let me read this file to see if it's the right one" costs tokens and time before any work happens.

So I made the house a floor plan. One file with every folder, every dependency and every function, sitting in the repo. One line in CLAUDE.md tells the agent to read the plan first. Then it walks straight to the room it needs, like a person who has been here before.

The first desktop version started a dev server from a hardcoded path on my own Desktop. It worked perfectly for exactly one human being on Earth. This one works for you too.

What it does

Read it once, map it, hand it over.

Reads the folder. Pick a project folder or a zip, or drop one on the window. Cartograph reads it and never writes a byte back.
Skips the junk, out loud. node_modules, .git, build output and whatever your .gitignore says get named in the map with a file count, so the agent knows they exist, but they're never opened. .env files and keys are listed by name and never read.
Writes the map. Directory tree, dependency tree (npm, Python, Cargo, Go, Maven, Gradle, .NET and more), a language breakdown, and the functions, classes and exports in every file. Pick how deep: Map, Skeleton or Contents. Pick Compact if you want it lean.
Leaves a note for the agent. Add to CLAUDE.md puts one rule at the end of the file: read the map first, then open one path. Nothing already in the file gets touched.
Gets out of the way. On Cartograph's own source, the default map is about 3k tokens against roughly 45k for the code. That's over 90% less reading before the agent does anything useful. On Fathom it's 4.6k against 105k.

Cartograph with its own source loaded: 2.9k map tokens against 44k source tokens — Its own source, mapped: 2.9k tokens for 44k of code

The Agents tab with the rule Cartograph adds to CLAUDE.md — The rule for CLAUDE.md

The dependency tree for Cartograph's own package.json — Dependency tree

The compact format of the map — Compact: 1.6k tokens, 96% smaller

Things it got wrong

So it won't get them wrong for you.

1 fileout of 118

I pointed it at one of my own projects and got a map of a single file. Python virtual environments ship a .gitignore that just says *, meaning "ignore everything in here." Cartograph applied that to the whole project. A nested .gitignore now only counts inside its own folder, like git does, and the same project maps all 118 files.

−80%and a lie

An early version bragged that the map was 80% smaller than the source. It was counting node_modules as source, which is like saying you saved money on groceries by not buying the store. Measured honestly, the tiny sample project's map was bigger than its code. So the sample is now Cartograph's own source, and the 90%-plus is real.

Zone capital letter

Rust dependencies vanished from the map whenever [dependencies] was the last section of Cargo.toml, which is basically always. The parser ended the section at \Z, which means "end of file" in most regex flavors and "a capital Z" in JavaScript. No Z, no dependencies. There's a test for it now.

1 userworldwide

The first desktop build ran a web server out of a folder on my Desktop, by full path. Released as-is, everyone else would have downloaded a very nice blank window. It's now one self-contained app that needs nothing installed.

Why you can trust it

It reads your code. It doesn't touch it.

Read only. Cartograph never writes to the project it scans. Not a temp file, not a cache, nothing.
Secrets stay secret. .env, keys, certificates and .npmrc are listed by name so the agent knows they exist. Their contents are never read into memory, let alone into the map.
You click, it writes. The only files it ever writes are the map you save and the rule you add, both through a Windows dialog you confirm.
CLAUDE.md is sacred. The rule goes on the end. Existing text is never changed, the file keeps its line endings, and if the rule's already there it writes nothing.
It's offline. No account, no telemetry, no uploads. Even the fonts are bundled. It doesn't phone home, mostly because it doesn't know your number.
No AI inside. The map is built by plain parsers you can read. It's a tool for agents, not another one.

Get it

Free. Draw the map.

Download for Windows Source on GitHub

Windows 10 and 11, 64-bit. Grab Cartograph-Setup-1.0.2.exe to install it, or Cartograph-1.0.2-portable.exe, which is the whole app in one file.

The builds aren't code-signed yet, so Windows may say "Windows protected your PC" the first time. Click More info, then Run anyway.

Open source under the MIT license. Built with Tauri, Rust, React and TypeScript. Built with help from Claude, which was also its first customer.