Sense gives your AI agent superpowers. I spent two weeks trying to prove it doesn't.

The least trustworthy person in dev tools is a builder quoting his own benchmark. I build Sense, an MCP server that gives coding agents a structural map of a codebase, and I want you to install it. So before this post could exist, the benchmark had to be built like a weapon aimed at me.

Here's what survived it, what's next, and the experiment that lets you skip trusting me entirely.

The setup, built to be hostile

Two arms, same agent, same prompt, same repo at a pinned commit. The only variable: one arm can query the map, the other can't. The task is the nastiest structural chore I know, the teardown audit: before changing how a central model is torn down, find every place that depends on it. Recall gets graded against an answer key built by hand, by reading the code, before any run. No vibes-based judging.

Scale: 13 repos, from GitLab (68,289 files, 36,829 indexed, 1,121,147 edges between 177,929 symbols) down to gems that fit in a single context window. 3 harnesses, 5 models, US frontier to EU-open. Every transcript is public, replayable, and cited against the pinned commit.

Running hostile also made the tool harder mid-series: three repos exposed gaps (a symbol-disambiguation edge on Mastodon, a determinism cap on GitLab, Solidus' acts_as resolver) and every fix shipped before the next repo ran. The first AI judge got fired for grading too kindly; that story is its own post. A bench you build to lose doubles as a build system.

What survived

12 wins, 1 tie, 0 losses. Average recall lift +0.26 across the board. Tokens usually dropped too (~18% on Chatwoot), but that's the side effect; reach is the purchase.

Three cells to make it concrete. Chatwoot: cold agent found 2 of 11 scattered dependents of Inbox and stopped there; mapped, 11 of 11, full score 0.29 → 0.97. GitLab's MergeRequest: sense_blast returns 932 impacted symbols; the cold agent surfaced a handful, 0.26 → 0.67. Rails itself, the most memorized codebase on earth: 0.67 → 0.92, and the lift sits almost entirely on internals no blog post ever wrote about.

The counterintuitive row: the weakest model gained nearly as much as the strongest (+0.24 vs +0.26), from a much lower floor. A map does the remembering a small model can't. That matters if you're running local or cheap models on real codebases.

What it actually is (the showdev part)

One Go binary. sense scan parses your repo into a local index: call graph, inheritance, composition, plus embeddings for semantic lookup. It serves that over MCP to whatever agent you already run (the bench used three different harnesses; if your tool speaks MCP, it works).

The whole surface your agent sees is five tools:

• sense_graph: callers, callees, relationships of a symbol
• sense_blast: what breaks if this changes, multi-hop, tests included
• sense_search: hybrid semantic + keyword symbol search
• sense_conventions: the patterns your repo actually follows, with strength scores
• sense_status: index health and coverage

Five on purpose. An agent discovers a five-tool surface by reading the descriptions; a thirty-seven-tool surface needs onboarding, and your agent doesn't read onboarding. After sense setup writes the MCP config, your involvement ends. You'll know it's working when your agent's answers start arriving with file:line citations you didn't ask for.

Runs on CPU, index is ~80 MB on disk for a large app, and the binary makes zero network calls. Your code never leaves your machine, which also means it works on the repos you're not allowed to paste into anything.

The next superpower

The board's lone tie (llm.rb, 0.48 → 0.48) is a gem tiny enough to need no map. That row is a target, and the roadmap pointed at it is convention depth: structure that exists only in your repo, so no model weights contain it and no model release ever will. Your naming scheme. The macro that wires a subsystem at runtime. The callback chain behind one innocent-looking delete.

This is already the deep end of the product: Rails support runs full tier (associations, callbacks, routes) plus closed-world dead-code proof for Ruby, and the Solidus resolver fix above is what one step in that direction looks like. Framework by framework, the map grows into the specifics your LLM will never train on, because they're yours.

Why this doesn't expire with the next model release

Three properties, none of which a bigger model changes: the index is built from your code at HEAD, which no training run has seen; it rebuilds as the code moves, so it's never a stale snapshot; and it's agent-agnostic over MCP, so the day you switch models, the map comes with you. Rails 0.67 → 0.92 is the proof cell: the model that memorized Rails best still gained the most where memorization ran out.

The 10-minute experiment (skip trusting me)

1. Open the repo you know best. Ask your agent, cold: before I change how [your busiest model] is torn down, find every place that depends on it. Save the list.
2. curl -fsSL https://luuuc.github.io/sense/install.sh | sh
3. sense scan in the repo root, sense setup to connect your agent.
4. Ask the same question, word for word. Diff the two lists against what you know is true.

That diff, on your codebase, is the entire pitch. Post it in the comments either way. The board is public and replayable; your repo would be run number fourteen.

Repo: https://github.com/luuuc/sense. Free, open source, with the full benchmark (methodology, answer keys, transcripts) in bench/.