Caveman Skill Token Savings: What v4.0 Installs and Which Numbers Hold Up

What Caveman is in v4.0

Caveman is an open-source project by Julius Brussee that began on April 4, 2026 as a single Claude Code skill and now ships as a bundle: an output-style skill, a CLI you install with npx, a local proxy that shrinks what the agent reads, an optional router called Auto that needs a Caveman account, and a scripts module called Blocks. Only the first piece is the viral “talk like a caveman” voice, and the voice only shortens the model’s replies. The larger figures on the README, 33.2% fewer input tokens and 54% cheaper with Auto, belong to other pieces and come from the project’s own benchmarks.

The short version of the evidence is this. The launch line was about 75% fewer tokens. The most careful independent test found by this guide, from JetBrains, measured 8.5% fewer output tokens on real coding-agent tasks with the skill forced on, and no measurable quality loss. A research paper that cites the repository found that compressing the model’s output cuts realized cost on most API models, while compressing your prompt raises it. Caveman’s own “Honest Numbers” page now says that no output reduction against default verbose replies is published, and lists the cases where the skill loses. Those statements fit together once you know which channel each number measures.

This guide is built from the project’s repository (README, INSTALL.md, SECURITY.md, HONEST-NUMBERS.md and the v4.0.0 release notes), the JetBrains post, the arXiv paper and the Elastic post, all of which were opened and read for this article. Nothing here comes from running Caveman; the one calculation done locally is a token count of the skill file, described below. Figures that move, such as star counts and version numbers, are stamped with the date they were read: October 29, 2026.

The 75% launch line

On April 4, 2026 the author posted a one-line install for Claude Code and described the result as “same fix. 75% less word. brain still big.” The post attached a screenshot of the first README, which says the skill is “cutting ~75% of tokens while keeping full technical accuracy.” The repository then did what few skill repositories do: it hit the front page of Hacker News. The submission, titled “Caveman: Why use many token when few token do trick,” shows 904 points and 366 comments in the Hacker News API as of October 29, 2026, and the repository now reports roughly 115,900 stars.

The 75% figure traces to a joke the author had seen, not to a benchmark, and the project has since walked it back in its own documentation. The Honest Numbers page states that earlier stats releases “applied a fixed 65% output ratio without a committed reviewed result,” that current reports ignore those estimated fields, and that the benchmark harness has no committed reviewed raw result for output reduction against default verbose replies. Its table lists that figure as “Not published.” The number that was repeated across social posts for months therefore has no measurement behind it in the project’s own words.

That does not make the skill useless. It means the 75% belongs in the category of marketing copy, and anyone deciding whether to install should read the measured rows instead. The measured rows are smaller, and they are more interesting.

The pieces: six rocks, three trust levels

The v4.0.0 release, published October 13, 2026, describes itself as making npx @caveman-ai/cli the one install, adding Auto routing through Caveman Cloud on top of the local proxy, and shipping Caveman Blocks as a module. The README calls the parts “six rocks” and the CLI switches them with caveman on and caveman off: output, input, waste-fixes, routing, scripts and browse. The table groups them by what they touch and whether an account is involved, using the data-flow table in SECURITY.md.

Two caveman commands touch your own prompt-adjacent files. /caveman-compress <file> rewrites memory files such as CLAUDE.md in a compressed style and keeps a backup. The README says it takes five files from 6,198 tokens to 4,138, between 22.8% and 49.1% each, and the creator’s own post put it as “1000 token CLAUDE.md × 100 sessions = 100,000 tokens on context you already wrote.” This is a different mechanism from the voice skill: it changes input that you pay for every turn, and the Honest Numbers page calls its result a total input reduction across five listed fixtures with no general quality-equivalence claim.

One design choice from the README echoes the research below: Caveman says it never rewrites your prompts. The project cites the Adobe paper for that decision, which found that stripping function words from the prompt raises net cost on most API models. The skill reduces how the model talks and leaves what you type alone.

Install for Claude Code, Codex and Cursor

INSTALL.md offers a unified installer and per-agent commands. The one-liners are pinned to a release tag rather than the moving main branch, and the document says hook files are checked against a SHA-256 list from the same tag. It is candid about the limit of that check: it “catches a broken or partial download, not a tag that was moved.” If you would rather inspect before running, the file suggests downloading the script, reading it, then running it, and the installer takes a --dry-run flag that previews what it would change.

Four practical details are easy to miss. First, on npm 12 or newer, a bare npx -y github:... command stops with EALLOWGIT because npm 12 turns off git package fetches by default; the document says to add --allow-git=root, and that the pinned v4.0.1 one-liners handle it themselves. Second, scripted Claude Code runs, meaning claude -p and the Agent SDK, start with Caveman off whatever your config says, so tools that parse Claude’s reply get plain text; you opt in with /caveman or the CAVEMAN_DEFAULT_MODE environment variable. Third, you choose the mode new sessions start in with a defaultMode key in ~/.config/caveman/config.json, or per project in a .caveman.json file. Fourth, subagent behavior depends on the host: Claude Code subagents start in the mode of the window that spawned them, while opencode subagents get fixed rules from AGENTS.md that “stop caveman” does not switch off.

INSTALL.md lists these paths and hook behaviors as the project’s documented design. No independent test of the Codex or Cursor hooks was found for this guide, so treat their behavior as the maintainer’s description until you confirm it in your own session. To remove only the skill, the README gives npx skills remove JuliusBrussee/caveman -g. The skill format itself is described in the Claude Code skills documentation, which explains why a skill’s size matters, covered under cost math below.

Which numbers are the project’s own

The README opens with four headline cards: 33.2% fewer input tokens, 54% cheaper with Auto, 397 to 76 tokens for one test run, and 1.4 to 2.4 times cheaper with caveman-style output. Only the last comes from outside the project. The table sorts every number in this article by who measured it and what it covers, so you can see which claims apply to the skill you are considering installing.

Two derived figures help read the output test. From the README table, the “Answer concisely.” control is already 37.9% below the no-instruction run (6,983 to 4,334 tokens), so most of the visible shortening comes from asking for brevity at all. Against that control, /caveman is 5.0% lower on the table’s totals and /ultracave is 37.9% lower. The README and the Honest Numbers page quote the median figures, 3% and 35%, and say the test ran on the 3.1.0 rules and has not been re-run. This guide’s inference, not the project’s: modern models already respond to “be concise,” so the skill’s marginal value over a one-line instruction lives mostly in the stronger modes.

The 33.2% result deserves a careful reading because it is the largest figure the project can defend with a table. It is measured on whole Claude Code sessions with a proxy that compresses file contents. The README itself lists the caveats: the session run is from August 2026 on an older engine, HTML has no compressor yet and got worse, and each test file hides one record in 61 to 72 KB of noise. The text adds that a competing tool, Headroom, got 15 of 18 right and 6.7% fewer tokens on the same suite. These are useful numbers for deciding whether to try the proxy. They say nothing about the voice skill.

What JetBrains measured

JetBrains published the most direct test in July 2026. The setup was a paired A/B on SkillsBench using Harbor 0.17 with Claude Code 2.1.200 in headless mode, the claude-sonnet-5 model at low reasoning effort, and 86 of the benchmark’s 87 tasks, with about 240 billed trials at roughly USD 106 in total. One arm was stock Claude Code. The other installed Caveman and added an instruction to force activation, which the post says makes every number the skill’s best case.

JetBrains explains the gap in one sentence: agentic output is dominated by code, diffs, tool invocations and exact error strings, which Caveman leaves verbatim, and only the narration between tool calls gets compressed. Their recommendation was to use the skill if you like it, because it costs nothing measurable in quality, while expecting a high single-digit percentage at most on daily agentic work. The company’s X post summarized the result the same way, and the accompanying image is a comic whose only data are the 100% and 91.5% token-use bars and the 8.5% label.

The caveman repository acknowledges this result. Its Honest Numbers page lists JetBrains among outside A/Bs, and the README’s “Proof” section states the lesson the project drew: agent sessions are mostly code and tool calls, which the voice leaves alone, so Caveman grew components that shrink what the agent reads. The 8.5% figure is for Claude Code on a single benchmark with one model at low effort. It is strong evidence about the voice skill on that workload and weak evidence about a Cursor chat or a long Codex session.

What the Adobe paper says

The README cites a paper titled around “Cavewoman,” arXiv 2606.24083, submitted June 23, 2026 and authored by Morayo Danielle Adeyemi, Ryan A. Rossi and Franck Dernoncourt; the README labels it Adobe Research. The paper cites the Caveman repository in its introduction. It evaluates eight models on five datasets at five reduction levels and scores every generation on accuracy, realized per-item cost and agreement with the model’s unconstrained reference, measuring the user’s prompt and the model’s response separately.

The headline finding has two halves. Output compression cuts realized cost on most API models, by 1.4 to 2.4 times per model and up to 3 times in the best case. Input compression has the opposite effect: the abstract calls it a strict lose-lose that raises net cost, by about 1.15 times on the five-benchmark mean, up to 1.8 times on the worst dataset and 2.7 times under stronger compression, because models answer at greater length while accuracy collapses. In the paper’s input-compression table, net cost moves by −2.6% for GPT-4o, +15.4% for GPT-5.4, +3.1% for Claude Haiku 4.5 and +5.1% for Claude Sonnet 4.6.

Three caveats from the paper itself matter for how you read the 1.4 to 2.4 figure. The authors say the output savings are largest on benchmarks whose reference answer is already short, such as yes/no and multiple-choice letters, and that these savings are “partly mechanical”; GSM8K, which needs multi-step arithmetic, shows smaller savings with accuracy preserved on the cells with a high parse rate. GPT-5.4 is cheaper on only two of its five benchmarks because its billed output is dominated by hidden reasoning tokens. And the paper says output tokens are typically priced four to eight times higher than input tokens, which is the reason an output-side saving can matter more than an input-side one. It tests a prompt-level constraint on short benchmark answers, not a coding agent with tool calls, so it supports the direction of Caveman’s idea more than the size of any agent-level saving.

Cost math for one SKILL.md

A skill is not free. The README says the voice rules cost about 1,160 tokens of input, and the Honest Numbers page lists the input cost the skill adds as “Not measured yet.” A local count of the v4.0.1 SKILL.md with the o200k_base tokenizer from tiktoken, which approximates but is not Claude’s tokenizer, gave 1,158 tokens for the whole file: about 70 for the frontmatter and 1,087 for the body. That agrees with the README’s estimate. Per the Claude Code skills documentation, descriptions are loaded into context so the model knows what exists, the full body loads when the skill is invoked, and the loaded body then stays in the conversation across later turns.

A simple break-even model follows. If a cold read of the file costs 1,158 input tokens and each output token costs a ratio r times an input token, the skill pays for one uncached read once it saves about 1,158 / r output tokens. With the four-to-eight range the Adobe paper cites for the price ratio, that is the table below. The model is a simplification: cached reads cost less than uncached ones and an always-loaded skill is re-read every turn, so the real balance depends on caching and on how many turns follow. The project says it has not measured it.

Against those thresholds the sample in the README looks fine: a React answer drops from 63 tokens to 20 (both counts reproduce with o200k_base), a saving of 43 tokens. That is a handful of questions to break even in the best case, and many more at the low end. For long agent sessions, an independent measurement in the Honest Numbers page puts the proportion in perspective: across 662 Claude Code sessions one user found output was 0.3% of all tokens and Caveman’s net effect on the bill was within ±0.2%. In another outside run with 300 runs per arm, billed output fell 44.1% while total cost moved +0.06%, with about 1,532 extra tokens of cached context per run. When most of the bill is input and cache re-reads, an output-style rule has little to act on.

The Honest Numbers page lists where the skill loses outright: terse coding Q&A where the fixed prompt overhead can exceed any output reduction (issue 145); agents billed per request such as GitHub Copilot, where a shorter answer is the same request (issue 506); and a Cursor A/B that showed 4.3M tokens with Caveman against 1M without, which the project says it could not reproduce and attributes to rule re-injection, retries and cache accounting. The page’s rule of thumb is the sensible one: compare provider-billed totals on the same task with and without the skill, and turn it off if the total goes up. For related ways to spend fewer tokens, see the guides on 9Router as a token saver and saving tokens in Antigravity.

Trust surface: CLI, proxy and account

Installing the skill alone is a small decision: a markdown file and, for some hosts, a hook. Installing v4.0 through npx @caveman-ai/cli is a larger one, because the CLI sets up a local proxy that sits between your agent and the provider, can detect and modify configuration for every agent and login it finds, and can offer a cloud account. SECURITY.md has a data-flow table that is clearer than most. This table condenses it; the quoted behavior is from the document as read on October 29, 2026, and the document itself warns that published releases can lag the repository.

Two details are worth underlining. The Auto row says raw means whatever your agent writes into those turns, which can include CLAUDE.md and memory reminders, file contents you mention and shell output, so an account-backed router is a data-sharing decision, not only a billing one. And the proxy sees your provider credentials in transit by design, which is true of any local proxy and is why the integrity of the install path matters. The release notes add that the module index is listed in a signed checksum manifest and that the CLI refuses an index the manifest does not list, which is a good sign about intent. This guide did not audit the code or the signing setup; the notes are the project’s description, not a verification.

A conservative path follows from the table. Start with the skill alone using npx skills add JuliusBrussee/caveman -g, which involves no proxy and no account. If you want the proxy, run the installer with --dry-run first, read what it will change, set caveman telemetry off if you do not want usage events, and check caveman status to see what is on. Leave Auto and the managed gateway for sessions where you are comfortable sending prompt text to a third party. The project’s vulnerability policy asks for private reporting through GitHub for issues such as credential exposure or proxy isolation failures, which is a reasonable signal that these are the surfaces it considers sensitive.

Measure it on your own work

The evidence above is an argument for testing, not for installing or avoiding. A proportionate test takes a day and uses only your normal billing data. The steps follow the project’s own guidance with a few additions drawn from the JetBrains method.

1. Pick one repeatable task. Choose work you do every week, ideally one that includes both chat answers and tool use, so the test reflects your mix rather than a README example.
2. Run it at least five times per arm. JetBrains’ first 10-task run showed about 30% and the full run converged on 8.5%. Single runs are noise.
3. Compare provider-billed totals, not output length. Use the usage or billing page of your provider. The project says this outranks its own estimates, and its /caveman-stats command reports savings as unknown for exactly this reason.
4. Include the skill’s own cost. Add the approximately 1,158 tokens of the file and note whether your agent re-injects it on every turn. The Cursor report on the Honest Numbers page is the cautionary example.
5. Check quality separately. Count correct outcomes as JetBrains did. Token counts do not prove that a terse answer kept every caveat; the project says it publishes no reviewed fidelity snapshot yet.
6. Test the voice and the proxy separately. Use caveman on and caveman off to switch one piece at a time, so you know which one moved your bill.

If you are weighing models rather than tools, a bigger lever than any style rule is often the model and effort setting itself; our Claude Opus 5.5 vs Sonnet 5.5 coding comparison covers that trade. If your concern is running out of allowance rather than money, see the Codex usage reset guide, and for the way persistent context changes token use, the Claude-Mem guide and the Claude Code best-practice guide are the nearest neighbors.

The practical verdict

Caveman is a fun, low-risk way to shorten replies, with an honest ceiling for agent work, and a larger tool whose bigger claims are still the project’s own. The voice skill is well documented, keeps code and numbers exact, and in JetBrains’ test showed no quality loss. Its realistic effect on a coding agent is in the single digits for output tokens, and the project’s own pages say it can lose on terse coding Q&A and on per-request billing. The 75% launch line has no measurement behind it. The 1.4 to 2.4 times figure from the paper is real but flatters short-answer benchmarks.

The v4.0 additions are a separate decision. The proxy’s 33.2% result and Auto’s 54% result are promising, specific and self-reported, with caveats the README prints itself. Try the skill alone first, run your own A/B on provider totals, and add the proxy only after reading the data-flow table and deciding that the trust surface fits your environment. If your A/B shows a higher bill, the project’s own advice is to turn it off.

Limitations

• This guide did not run Caveman. The one local computation is a tiktoken o200k_base count of the v4.0.1 skill file; that tokenizer approximates, and is not, the tokenizer Claude or Codex bill with.
• Every Caveman benchmark figure here (output test, 33.2%, 54%, 397 to 76, 4,138 from 6,198) is the project’s own and was not reproduced. The Auto result is labeled interim by the project, with the run half done and a gap smaller than the stated error.
• The JetBrains result is one model at low effort on one benchmark with activation forced. The Adobe-authored paper tests prompt-level constraints on benchmark questions, and its authors’ affiliation is taken from the README, not checked on the paper’s title page.
• The outside A/B results from LemonCrow and edubraqd, and the Cursor report, come from issues summarized on the Honest Numbers page. They were read there, not on the issue threads, and they used older versions of the skill.
• Codex and Cursor activation is taken from INSTALL.md. No independent test of those hooks was found.
• SECURITY.md describes repository behavior and says published releases can lag. Binaries, the Cloud service and the signing setup were not audited.
• Star counts, forks, release tags and the Hacker News score are as of October 29, 2026 and will change. The README’s social-proof claims, such as a #1 GitHub Trending placement, were not independently verified. A YouTube video the README links was not watched and is not cited.

FAQ

Sources

Sources read October 29, 2026.

• JuliusBrussee/caveman on GitHub (README, repository metadata) and INSTALL.md
• Honest Numbers and Security and privacy
• Caveman v4.0.0 release notes and SKILL.md at v4.0.1
• JetBrains AI blog: Speaking to AI Agents Like Cavemen Saves 65% of Tokens. We Test. and the JetBrains post on X
• arXiv 2606.24083, Cavewoman: a two-channel evaluation of caveman-style compression
• Elasticsearch Labs: elastic-caveman
• Julius Brussee on X, launch post and the Hacker News submission
• Claude Code documentation: Skills

Related reading: 9Router token saver guide, Antigravity: save tokens and reduce quota, Claude Code best practices, Claude-Mem persistent memory, Claude Opus 5.5 vs Sonnet 5.5 for coding, Codex usage resets.