Caveman Skill Review: Does It Really Save 65% of Tokens?

The caveman skill is one of the most shared Claude Code skills of the year: a simple instruction that makes the agent answer in caveman speak — no articles, no pleasantries, no hedging. Same code, same technical terms, just a much shorter mouth.

The pitch that made it viral is a number: 65% fewer tokens. This review checks where that number comes from, what independent tests found, and — the part most coverage skips — what it actually does to your bill.

Where the 65% came from

The author of JuliusBrussee/caveman ran ten ordinary coding prompts through the Claude API, with and without the skill. Output tokens dropped by 65% on average. The range is wide:

• Implement React error boundary: 87% saved
• Set up PostgreSQL connection pool: 84% saved
• Debug PostgreSQL race condition: 81% saved
• Docker multi-stage build: 72% saved
• Explain git rebase vs merge: 58% saved
• Review PR for security issues: 41% saved
• Architecture: microservices vs monolith: 30% saved
• Refactor callback to async/await: 22% saved

The pattern is honest and simple: when the agent would have written an essay, you save a lot. When the answer was mostly code — and caveman mode never touches code — you save very little.

What independent tests found

Three independent replications landed in the same, lower zone:

• Kuba Guzik ran a three-arm test across 72 identical prompts: caveman beat a vanilla assistant by 23%, but beat a plain one-line "be concise" instruction by only 4%.
• Marco Pillitteri measured 12% savings on coding tasks.
• MayhemCode logged a full Next.js session: 11,200 output tokens down to 8,900 — 20%.

The author's own evals now tell a similar story. The repo ships a three-arm harness comparing against "Answer concisely." — the honest baseline, since modern models already know how to be brief. On top of that line, /caveman cuts about 3% more at the median; /ultracave cuts about 35% more. And the author has acknowledged publicly that real-world savings land "closer to 20–30%".

An independent analysis by Implicator adds the missing bill math: in a typical Claude Code session, output tokens make up only 0.6–2.5% of total token spend. A 20% cut to that slice caps real bill savings at roughly 1–3%. Three independent benchmarks also confirmed zero correctness regressions at default intensity — the skill is honest about what it compresses.

The fine print the author discloses himself

To its credit, the caveman repo is unusually upfront about its limits — a recent dev.to walkthrough collects them well:

• The skill only shortens output. Input and reasoning tokens don't change.
• The skill's own rules add roughly 1,000–1,500 input tokens on every turn.
• Whole-session savings will be lower than the benchmark table suggests, and on work that was already terse you can end up paying more.
• The README says speed and readability are the real product; the discount is a bonus.

That last line is the most honest sentence in the whole saga. Read the caveman transcripts: the value isn't really the 1–3% bill cut. It's that long agentic sessions become scannable. Status updates you used to skim become one line. Whether that's worth 1.5k input tokens per turn is a per-workflow question, not a headline number.

The second rock: input tokens

The project grew a second component worth knowing about: a proxy that compresses what the agent reads, not what it writes. The published CaveBench Wrap benchmark — six fixtures of CSV, logs, YAML, test output, and JSON, 18 runs, exact-answer oracle — reports 33.2% fewer input tokens across whole Claude Code sessions, with all 18 answers correct. Input is the side of the bill that actually matters, and this is where the interesting cost work is happening. Note the spread behind the average is wide (55% saved on a CSV-heavy session, 10% worse on an HTML-heavy one with no compressor yet), so measure your own file mix.

When it's worth it, and when it isn't

Worth trying: long agentic loops with heavy back-and-forth, code review pipelines, CI-adjacent automation — anywhere the agent narrates more than it codes. The /caveman-commit and /caveman-review commands are genuinely useful on their own.

Skip it: code-heavy sessions (code is untouched, so savings approach zero), workflows that are already terse, exploratory or creative work where you want the model's full reasoning surfaced.

A free baseline exists: a one-line "answer concisely" instruction captures most of the benefit (remember Guzik's 4%). Caveman's edge over that line is the persona — models follow a concrete character better than an abstract instruction — plus the command tooling.

How this relates to stop-slop

Caveman and our stop-slop skill look similar from a distance — both fight the same enemy, the LLM's default verbosity — but they solve different problems. Caveman makes the mouth smaller: fewer tokens out of the API. Stop-slop fixes what the words sound like: it strips the telltale AI-isms ("delve", "in today's fast-paced world", the em-dash confetti) from writing meant for humans to read. One optimizes your token bill; the other optimizes your readers' trust. They stack fine — run caveman in the agent loop, stop-slop on anything a human will see.

The verdict

The 65% number is real measurement on a specific prompt set, not a fabrication — and it's also not your number. Expect ~20% less output in real sessions, 1–3% off the actual bill, and meaningfully faster-to-read transcripts. The input-side proxy is the more interesting long-term bet. As a free install with an uninstall command, it's cheap to test on your own workflow. Just don't quote the headline at your finance team.