Caveman Skill: What the 65% Really Buys

The caveman skill has 99,743 GitHub stars as of August 21, 2026, a landing page headline promising to cut 65% of your AI costs, and a README that tells you, in the author's own words, that the savings can go net-negative. All three of those are true at the same time, and the distance between them is the entire installation decision. Working out which number applies to you takes about ten minutes.

Key Takeaways:

• Two different things ship in one repository: a prompt skill that shrinks what the agent writes, and a proxy runtime that shrinks what the agent reads. They have separate benchmarks and separate licences.
• The 65% figure covers output tokens on a ten-prompt table. The 33.2% figure covers provider-reported input tokens in a 54-run Claude Code benchmark, and only applies when you run the wrap command.
• The repo's own HONEST-NUMBERS.md says the skill adds roughly 1,000 to 1,500 input tokens per turn and can lose money on workloads that were already terse.
• The licence is split. The skill is MIT; the engine, proxy, browse and MCP pieces are BSL-1.1, which is source-available rather than open source until it converts to Apache-2.0.
• JetBrains published a rival token-efficiency skill four days ago with a paired A/B behind it, and its measured effect is smaller and better evidenced.

What the caveman skill actually does

Talk like a caveman. That's the mechanism of the caveman skill, and it is not a joke about the branding: it instructs Claude Code to drop articles, pleasantries and connective filler, then hand back the same technical content in a fraction of the words. The README's own comparison puts a normal agent explanation at 69 tokens and the caveman version of the same explanation at 19.

Julius Brussee created the repository on April 4, 2026. By August 21 it carries 5,800 forks, 372 commits and 24 tagged releases, with v2.2.0 shipped on August 20. Release cadence matters more than star count when you're deciding whether to depend on something, and this one moves fast enough that any version number here should be re-checked before you install.

The caveman skill itself is plain markdown with no executable code, which is why it spread the way it did. It also means the failure mode is mild: if the terse style annoys you, you delete the file. The other half of the repo is a Go runtime, and that one has opinions about your network traffic and your commercial licence, which we'll get to.

Two things ship under one name, and almost every write-up conflates them.

Where the 65% comes from, and where it stops

Caveman's homepage leads with "Cut 65% of your AI costs" in display type, and beneath it, in small monospace, the qualifier: 65% fewer output tokens, measured across 10 prompts. Those two lines say different things. Output tokens are one line on an invoice, not the invoice.

The README's benchmark table is where the 65% is actually derived. Ten tasks, baseline output tokens against the caveman skill's output tokens, averaging 1,214 down to 294. One row shows an auth middleware token-expiry fix going from 704 to 121, an 83% cut. Those are real measurements on a small sample, published with the per-row numbers visible, which is more than most projects at this star count bother to do.

The 33.2% is a different benchmark entirely. It belongs to caveman wrap, which routes your agent's provider traffic through a local proxy powered by Caveman Engine and compresses what the agent reads before every call, with byte-exact recovery. In a pinned 54-run Claude Code benchmark it reported 33.2% fewer provider-reported input tokens than direct Claude Code while passing all 18 exact-answer checks. The repo tags that result benchmark_counterfactual and reserves the tag verified for something else again: live traffic measured through Caveman Cloud with signed receipts. Offline caveman, by the author's own rule, never claims verified.

A third measurement is the largest and the least advertised. Caveman's browse module answers a focused query against a 200-row operations table in 121 tokens against a Playwright ARIA baseline of 15,704, which the repo calls 129.8 times smaller. If your agent spends its day reading web pages rather than writing code, that's the number that would change your bill.

The warning the author wrote himself

Buried in the README under a heading called "Honest number warning" is the paragraph that should decide this for most people. The caveman skill only shrinks output tokens. Input and reasoning tokens are untouched, and the skill's own instructions add roughly 1,000 to 1,500 input tokens to every turn. So whole-session savings run smaller than 65%, and on workloads that were already terse they can go negative. The author's stated position is that the real win is readability and speed, with cost savings as a bonus.

That is an unusually honest thing to put next to a landing page selling a 65% cut, and it gives you a clean test. If your Claude Code sessions are long, chatty, and full of the model narrating what it's about to do, the skill will pay for its own 1.5k per turn several times over. If you already work in short imperative prompts against small diffs, you are adding a fixed cost to every turn to compress output that wasn't large to begin with.

The awkward part is that measuring this properly means running both arms on comparable hardware for long enough to see past noise, and a laptop that sleeps halfway through the control run gives you nothing usable. That's the practical reason we built MoClaw as a hosted cloud AI computer rather than a local wrapper: an always-on machine is what a fair A/B needs, and it keeps running the second arm after you've closed the lid and gone to lunch.

Two licences in one repository

GitHub's sidebar shows "License, License licenses found" rather than a single name, which is the first hint. Open the LICENSE file and the scope note appears before the MIT text: MIT covers the repository except the Engine-linked directories, and those are BSL-1.1 under a separate file.

The BSL side covers Engine, Proxy, Cache Engine, the rewriter, Browse, the MCP server, shrink, the cavemem Go core and the shared Go platform. New Engine-linked modules default to BSL unless someone explicitly marks them MIT. Business Source License 1.1 is source-available, not OSI open source: you can read it, fork it, and self-host it for your own first-party traffic at no cost, production included. Each version converts to Apache-2.0 on the earlier of June 21, 2030 or four years after that version first ships.

The clause to read twice is the one about third-party use. Hosted, managed, or embedded service use needs a commercial licence. If you are a consultancy planning to run caveman's proxy on behalf of clients, or a platform thinking about bundling it, that is a procurement conversation and not a git clone. For an individual developer compressing their own traffic, none of it binds.

One more thing that belongs in the same paragraph as licensing, because it's the other question your security reviewer will ask: the CLI sends anonymous usage statistics by default. Which commands ran, and token counts through and cut. The README states it never sends prompts, code, or file paths, says so on first run, and caveman telemetry off or DO_NOT_TRACK=1 ends it permanently.

The other token-efficiency skill, with better statistics

Four days before this article, on August 17, JetBrains published benjamin-plus-skill, and it is worth comparing because the evidence is built differently.

Benjamin doesn't compress prose. It changes how the agent looks things up and waits: gather facts in one combined pass instead of five pokes at the repo, read 50 lines when the agent only needs to see something, check every dependency in one command, treat the task's own verification command as the definition of done, and poll a running build every 30 seconds instead of every second. That last habit alone, JetBrains reports, accounted for nearly half of all steps on some agent platforms.

The measurement is a paired A/B across 80 SkillsBench tasks on Claude Code 2.1.201 in Docker sandboxes with Sonnet 5, Wilcoxon on the paired deltas, with a per-trial check confirming the payload reached the model in 80 of 80 treated runs and 0 of 80 controls. Median cost fell 17.9%. Quality came out 7 better, 5 worse, 68 ties. On Java SWE-bench with Codex CLI and 675 paired replicas the effect shrank to 4.4% with a confidence interval of 7.5 to 1.5 and solve rate unchanged.

Both projects land on the same uncomfortable conclusion, which is that the effect size depends almost entirely on how wasteful your sessions were to begin with. JetBrains says as much: an identical run a day earlier measured 10% against a leaner baseline, and the treated arm stayed flat across both days while the control drifted upward by 10.5%. Your baseline is not a constant. That is also why a fair comparison needs a machine whose conditions you control end to end, which is one of the less glamorous reasons teams move this kind of measurement onto MoClaw rather than running arm A on a laptop in the morning and arm B on the same laptop at 4pm with nineteen browser tabs open.

The finding that generalises beyond either project: JetBrains tested the same skill text delivered two ways, and injecting it into the system prompt saved 17.9% while shipping it as a discoverable skill folder saved 0.5% and nothing statistically. Agents burned the difference hunting for SKILL.md. If you maintain a skills directory, that result is worth more than either token number. Our roundup of the best Claude skills covers what else is in that directory and how the discovery cost adds up.

Who should install it

Install the caveman skill if your sessions are verbose, if you read a lot of agent output yourself, and if a terse assistant sounds like an improvement rather than a personality clash. It's markdown, it's MIT, and reverting costs nothing.

Run the wrap and the proxy only after you've read the BSL scope and decided your use is first-party. That path also moves your provider traffic through a local process, which is a different security review than adding a text file, and it's worth noticing what it assumes: a proxy is only compressing anything while the machine hosting it is powered on. Compression that lives on your laptop stops the moment the laptop does, whereas an agent running on MoClaw keeps its whole toolchain, proxy included, on a machine that was never going to sleep in the first place.

And treat every percentage here, ours included, as a claim about someone else's workload. The one number that matters is what your own bill does over a fortnight with the skill on, which you can only see if the sessions ran on something that stayed awake for all fourteen days. MoClaw exists for exactly that shape of work: a hosted machine that holds the session, keeps the context, and doesn't stop because a laptop lid closed. If token accounting is the reason you're here, our note on the Sonnet 5 tokenizer change covers the other half of why last month's numbers stopped matching this month's.

FAQ

Is the caveman skill free and open source?

Partly. The skill and the adoption surfaces are MIT. The engine, proxy, cache engine, rewriter, browse module, MCP server, shrink and the cavemem Go core are BSL-1.1, which is source-available rather than OSI open source until each version converts to Apache-2.0 on the earlier of June 21, 2030 or four years after it ships. Self-hosting for your own traffic is free; offering it as a hosted or embedded service to third parties needs a commercial licence.

How much does the caveman skill actually save?

The repo's ten-prompt table averages 65% fewer output tokens. The separate caveman wrap benchmark reports 33.2% fewer provider-reported input tokens across 54 runs. Neither is your invoice. The README's own warning is that the skill adds about 1,000 to 1,500 input tokens per turn and can go net-negative on already-terse sessions, as of August 2026.

Does the caveman skill work with Codex or other agents?

The benchmarks, the slash commands and the plugin packaging are all built around Claude Code, and that's where the published evidence lives. The repo does ship a .codex directory and a skill-conversion command, so other harnesses are in scope, but there is no equivalent measured result for them in the README as of August 2026.

Is a token-efficiency skill worth the setup at all?

On verbose workloads, yes, and JetBrains' paired A/B puts a defensible 10% to 18% cost reduction on that claim. On short, disciplined sessions the fixed per-turn overhead can outweigh what gets compressed. The honest answer is that it depends on how bloated your sessions run, which is measurable and worth measuring before you commit.