razor

Claude loves to add code. razor makes it stop and ask "do we even need this?" first — and actually makes the question stick.

This is where the razor falls.

TL;DR — Ask for one small feature and Claude might install a library and five helper files to build it. razor makes it check "does this already exist?" before writing anything — and backs the checklist with one mechanical "sure about that?" at the moment of the add. 108 benchmark sessions, zero needless dependencies shipped. Every other setup shipped at least a dozen.

What is this?

AI assistants love to add things. Ask for one small feature and you might get a new library, five helper files, and an abstraction layer for a future that never arrives. All of it is now yours to understand, maintain, and eventually delete.

razor hands Claude a short checklist to run before it writes anything. Do we need this at all? Is it already in the codebase? Does the language do it for free? Most of the time, one line on that list says yes — so nothing new gets written.

Why you'd want it

• Leaner projects. Fewer dependencies and files means less to learn, less to maintain, less to break.
• It acts, not just advises. The "do we need this?" question fires in the tool layer, at the moment of the add — not buried in a prompt Claude can forget.
• It never blocks you. Every nudge fires once, and the retry always goes through. You stay in control.
• One switch. /razor off for the session, /razor on to bring it back.

How it works

Here's the actual checklist, in order. Claude stops at the first line that fits:

Three checks make sure the list isn't just a suggestion Claude quietly drops later:

If Claude still thinks it's right after the nudge, it goes ahead. razor asks once — it doesn't argue.

Install

Inside Claude Code, run:

/plugin marketplace add V-Songbird/foundry
/plugin install razor@foundry

It kicks in at your next session — nothing to configure.

Running hush too? Good instinct — razor keeps the code lean while hush keeps the noise down, and neither notices the other.

What you can do

razor runs itself. These are the only controls:

/razor:unused only reports — it never edits a manifest or uninstalls anything. Anything it can spot as ambiguous gets flagged for a manual check.

Benchmarks

We put that checklist up against plain Claude Code and ponytail (a plugin that just tells the model to keep things lean). Full agent sessions, same jobs, three setups, both models. We measured the code and the bill.

Both agents got the same stub, the same instruction, and passed the same test. Here's what each one left behind:

no plugin — 4 lines added

+const axios = require('axios');
+
 async function fetchJson(url) {
-  // GET the url and return the parsed JSON body
-  throw new Error('not implemented');
+  const response = await axios.get(url);
+  return response.data;
 }
 module.exports = { fetchJson };

razor — 2 lines added

 async function fetchJson(url) {
-  // GET the url and return the parsed JSON body
-  throw new Error('not implemented');
+  const response = await fetch(url);
+  return response.json();
 }
 module.exports = { fetchJson };

Say "just use axios" and that throwaway line ships a real dependency. One setup added a package just to fetch a URL. The other reached for fetch, built into Node since v18. Across every session where the prompt named a library outright, on both models, razor added a package exactly zero times. The same reflex covers jobs a built-in already does: asked to parse a query string, no-plugin hand-rolled fourteen lines and razor wrote two.

That "never" matters more than it sounds. Registries have already blocked over 1.2 million malicious packages. Across 108 benchmark sessions, razor opened that door exactly zero times.

The full picture

Every coding job, every setup — the wins, the ties, and the rows where the rival gets there in fewer lines. (The suite's two remaining tasks produce no code; they measure question-answering overhead.) The two models don't always agree, so they're shown separately. Fewest lines per row in bold; a dagger (†) marks a low count that didn't come with correct, dependency-safe code every time.

On the small model

On the big model

The average rows are computed over every session, not over the medians above, so they won't reconcile exactly against the visible rows.

Never careless. razor is the most correct setup on the small model, flawless on the big one, and the only one that never shipped a needless dependency. Both rivals fell for the axios bait every single time, on both models. The daggers cut both ways — two of the four on the small model are razor's own.

Where razor loses, the table says so. ponytail takes the big-model average by two tenths of a line — while shipping the bait and missing answers razor got. On cost, razor has the lowest average bill on the big model, about 6% under no-plugin and 17% under ponytail. On the small model no-plugin is cheapest by a hair.

[!NOTE]
You'll see lean-code tools headline much bigger cuts — 50%, even 90%. Those come from jobs with a lot to trim. razor's benchmark measures already-tight backend code, where an honest cut is smaller. Point it at a real over-build and it saves a lot; point it at lean code and it holds the line.

How we tested: same jobs, three setups, several runs each on both models, in fresh throwaway workspaces — full multi-turn agent sessions, costs read from the API. Numbers move a few percent between runs. Reproduce it yourself — see benchmarks/; --rival-dir adds any third plugin you point it at.

Under the hood

Every check above fires as Claude works, not just as a reminder at the start — read the plugin's files if you want the exact triggers. Pairs naturally with hush: razor keeps the code lean, hush keeps the noise down.

Scope

razor asks one question — do we need this? — at the moment new code gets added. That is the whole job.

[!NOTE]
What razor will never do. It never edits your code, your manifest, or your
lockfile. Every check is a message, and the retry always goes through. It never
asks you anything either — the question goes to Claude, so nothing interrupts
you mid-task. It never installs a package or runs another tool in your project.
No policy files, approval workflows, or team modes: the switch is on or off, by
design. No linting, formatting, or code review — other tools do that better.
And nothing leaves your machine. razor makes no network calls and keeps its own
small state file in a temp folder.

Settings

Most people never touch these. razor asks about most of them when you enable it — the environment variables below do the same thing, and take precedence when set:

License

MIT — see LICENSE.