# A Claude Code Skill with 86k Stars Says It Cuts Tokens 65%. It Cut My Bill 1%. > Source: > Published: 2026-07-07 00:00:00+00:00 There's a Claude Code plugin with 86,000 stars that saves you tokens by making the AI talk like a caveman. No filler, no pleasantries, just grunts. Fewer words out, smaller bill. Obvious, right? I tried it. The AI really did get terser. My bill didn't budge. Here's why — and it's the part actually worth knowing. ## Not all tokens cost the same You're billed for three kinds of token at wildly different prices. The words the model *writes back* are the dearest. The text you *send in* is cheaper. And *re-reading* context it has already seen is the cheapest of all — but there's a mountain of it. On Sonnet that's **$15, $3, and $0.30 per million tokens** — output priced 5× the input and 50× the cache-read. Here's the mountain. Every turn, the model re-reads the whole conversation so far — your files, the test output, the earlier back-and-forth — and then adds a few new words on the end. So a real session is almost entirely that re-reading. The words the model actually writes come to about **1% of the tokens**. Token economics Output = 1% of the tokens Pooled across my runs, two rulers 1% Output — what the skills cut A sliver of the volume. Now switch the ruler to dollars → Output is ~1% of the tokens but ~20% of the bill — pooled across my runs; your cache-to-output mix moves it. Even a perfect 65% cut shaves ~13% off a fifth; the rest of the bill never moves. Caveman shrinks those words. But 1% of the volume, even priced ~50× more than the re-reading, works out to only about **a fifth of the cost** — and that fifth is the *only* slice the skill touches. Cut it to zero and four-fifths of your bill hasn't moved. That's the whole thing: caveman optimizes the 1% you can see and leaves the 80% you can't. On a subscription — Pro or Max, which is most of us — your "bill" is really a usage quota, not dollars. Same story, though: Anthropic says its [limits are cost-based](https://support.claude.com/en/articles/11647753-how-do-usage-and-length-limits-work), so the pricey output still weighs the most and there's still barely any of it. They don't publish the exact formula, so I measured dollars — the number I can pin down — but compressing a sliver of the volume won't buy you much runway either. ## So I measured the cost, not the token count I ran seven coding tasks — from a one-line helper to a multi-file refactor — with the skill and without, metering the real dollar cost of each run with ** vigiles**, an open benchmark harness I built to measure cost instead of token counts — then added up what each actually cost. It reruns on your own Claude subscription: [the same seven tasks, with the skill and without](https://github.com/zernie/vigiles/tree/main/bench/ecosystem). The skill works: on most tasks the AI wrote less. But the output only shrank about **6% on average**, not the 65% on the label. And the total cost landed **within 1%** of not using it at all. A real cut to the words, no change to what you pay. (I tried a second popular "token-efficient" skill too — its output *grew*, and the cost went **up 10%**.) ## ▶The full numbers (per-task, both skills, p-values) Seven tasks × five paired runs each = 140 runs on Sonnet (~$10 API-equivalent, $0 on my subscription). Output change per task — negative means the skill cut output, positive means it grew — with the Welch p-value; `*` is significant at p<.05, and the two Caveman cuts (.002, .006) also clear a Bonferroni correction for the seven tasks. "The bill" is pooled dollars across every run; the output column is the mean of per-task ratios, so the two use different denominators and don't line up 1:1. | Task | Caveman outΔ | p | token-efficient outΔ | p | |---|---|---|---|---| | slugify | +54% | .27 | −2% | .78 | | debounce | −28% | .22 | −7% | .52 | | bugfix-offbyone | −31% | .002* | −6% | .87 | | bigO | −18% | .27 | +6% | .79 | | regex-email | −28% | .006* | +127% | .037* | | review-doc | −8% | .80 | +54% | .46 | | refactor-suite | +21% | .65 | +33% | .19 | Pooled bill: **Caveman −1%** (flat), **token-efficient +10%**. Output is ~20% of the dollar cost either way, and every answer stayed correct. On the dollar side per task (the numbers carrying the thesis): Caveman's −1% is small moves both ways — a bugfix −16% (p=.03), the rest inside the noise. token-efficient's +10% is spread across tasks (regex-email +49%, review-doc +21%, refactor +9%, bigO +6%), not one outlier — debounce (−13%) is the only task that got cheaper. Full per-task dollar deltas + p-values are in the JSON. Raw runs: [the 140-run JSON](/data/token-savings-runs.json), and the [ /caveman-compress test](/data/token-savings-compress-runs.json). Method + harness: [.](https://github.com/zernie/vigiles) `vigiles` One exception, for completeness: the API's *per-minute* rate limits are a different axis from cost. For most models cache-reads don't count toward the input-rate limit, and output has its own bucket — so if you're pinned against the output-per-minute ceiling specifically, trimming output does buy throughput. That's a narrow case, not your monthly bill or quota. ## Its other trick doesn't help either To its credit, the skill knows the output is a small target, so it ships a second tool that compresses your *instructions* file instead. I shrank one by 68% with it. The cost still didn't care — a 500-token file is a rounding error next to a 100,000-token session. Input compression · /caveman-compress file −68%, bill −14% (n.s.) It compressed the conventions file 68%, beating its own 46% claim. The bill moved 14%, but that's inside the run-to-run noise: a 500-token file is a rounding error next to a 100,000-token session. ## Where the savings actually are If you want a smaller bill — or more runway before you hit your limit — don't squeeze the words. Look at what reloads every single turn: **Big files and command output you pulled in once.** A file you opened, a 10k-line test log, a sprawling`git diff` — read a single time, then silently re-read on every turn for the rest of the session. That reloaded pile, not the model's replies, is what quietly grows your bill.**A bloated conversation.** Hand work to subagents so the main thread stays small instead of dragging a growing context through every turn.**Never pruning.**`/compact` and trimming cut the big cheap pile directly — the pile that's almost all of your cost. Note the one that *used* to headline this list: unused MCP servers. Current Claude Code loads MCP tool definitions [on demand](https://code.claude.com/docs/en/mcp#scale-with-mcp-tool-search) instead of shipping every server's whole tool list each turn, so idle servers barely cost you now — the old "prune your MCP list to save tokens" advice is mostly obsolete unless you've pinned a server to always load. Which is the whole lesson again: the token math moved, so the folk wisdom is a year stale. I haven't benchmarked those the way I benchmarked the skill, so treat them as leads, not promises. But that's where the money is. ## Before you install the next one Ask it one question: which tokens does it cut, and did anyone measure the actual *cost* — not the token count — on a real session? If the answer is "it makes the model write less, measured on one prompt," you already know what it'll do to your bill. Maybe it works. Maybe the model really does say less. But the words are a sliver of what you pay, and you'll barely feel it.