Caveman: Does Speaking Like a Neanderthal Actually Cut Your AI Bill?

There is a cost per word your AI assistant writes. Not metaphorically — literally. Every token that Claude, GPT-4o, or Gemini outputs hits your API invoice. If you are using a tool like Claude Code or Codex in a non-trivial workflow, your agent is generating thousands of tokens per session explaining things you already know, wrapping answers in politeness scaffolding, and restating context you supplied two messages ago.

This is Token Anxiety: the slow creep of realizing that verbose AI output is not just annoying — it is expensive, it erodes your context window, and in latency-sensitive workflows, it measurably slows you down.

Enter Caveman — a skill/plugin for AI coding agents that compresses output to its bare functional minimum. The project’s tagline is its own product demo: “Why use many token when few token do trick.”

With 71.9k GitHub stars, 4k forks, and 38 contributors as of June 2026, this is not a toy. This article breaks down whether the compression actually holds up under technical scrutiny.

1. What Is Caveman, Really?

Caveman is not a model. It is not a wrapper. It is a skill file — a SKILL.md containing tightly scoped instructions that tell a supporting agent to strip filler language, use fragments over sentences, and eliminate explanatory prose that adds no information density.

The philosophy is borrowed from telegraph operators and newsroom copy editors: substance in, ceremony out. The agent’s reasoning process (thinking tokens) is untouched — it still thinks in full sentences. Only the output payload is compressed.

┌─────────────────────────────────────┐
│  TOKENS SAVED          ████████ 75% │
│  TECHNICAL ACCURACY    ████████ 100%│
│  SPEED INCREASE        ████████ ~3x │
│  VIBES                 ████████ OOG │
└─────────────────────────────────────┘

It supports four compression levels:

It is also language-preserving: if you write in Portuguese, the agent grunts in Portuguese. Code, commands, paths, and error strings remain byte-exact.

2. Installation & Setup

The installer is genuinely one-liners that auto-detect which agents you have installed and wire the skill for each:

macOS / Linux / WSL / Git Bash:

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

Windows (PowerShell 5.1+):

irm https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.ps1 | iex

Requirements: Node ≥ 18, ~30 seconds. Safe to re-run (idempotent).

After installation, the experience differs by agent:

• Claude Code / Codex / Gemini CLI — Auto-activates every session via a lifecycle hook. No /caveman needed.
• Cursor / Windsurf / Cline / GitHub Copilot — Always-on rule files injected via --with-init flag.
• Other agents (30+) — Trigger manually per session with /caveman or the phrase “talk like caveman.” Deactivate with “normal mode.”

For targeting a single agent instead of all detected ones:

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash -s -- --only claude-code

The full installation matrix — per-agent paths, flag reference, uninstall instructions — lives in INSTALL.md.

Companion commands available post-install:

The statusline badge ([CAVEMAN] ⛏ 12.4k) shows lifetime tokens saved and updates every /caveman-stats run.

3. The Experiment: Methodology

Setup used for this benchmark:

• Agent: GitHub Copilot (Claude Sonnet 4.6) running inside VS Code
• Install command: npx -y github:JuliusBrussee/caveman -- --only copilot --with-init
• What it wrote: .github/copilot-instructions.md (caveman ruleset) + .agents/skills/ directory with all 7 skill files
• Token counter: Python tiktoken library, cl100k_base encoding (closest public proxy to Claude’s tokenizer)
• Compression level: full (the default)

Two test prompts were chosen to represent different token-cost profiles:

Test Case 1 — Conceptual/General Knowledge

“Explain how market-cap weighting in an index fund works and why smaller companies have less influence on the S&P 500 than larger ones.”

This is the kind of question a developer asks while context-switching — a quick Wall Street primer between debugging sessions. A vanilla agent will produce a structured multi-paragraph essay. Caveman should collapse this dramatically.

Test Case 2 — Technical/Coding Logic

“Write a Python function that prints a right-aligned staircase pattern of # characters for a given height n.”

A classic technical interview exercise. The code itself is short; the token cost in vanilla mode comes from the surrounding explanation — complexity analysis, edge case commentary, usage examples, and prose narration of what the code does.

Both tests were run with full compression mode active and compared against unmodified GitHub Copilot (Claude Sonnet 4.6) output on identical prompts. Caveman was installed into this repo via npx -y github:JuliusBrussee/caveman -- --only copilot --with-init, writing the ruleset to .github/copilot-instructions.md. Token counts were measured with tiktoken (cl100k_base encoding — the closest public proxy to Claude’s tokenizer) on the actual responses. All responses were generated in the same VS Code session on 2026-06-12.

4. Data, Statistics & Insights

Test Case 1: Market-Cap Weighting (Wall Street Question)

Vanilla Mode — GitHub Copilot (Claude Sonnet 4.6), no caveman rules:

Word count:    337 words
Output tokens: 438 tokens  (tiktoken cl100k_base)

The response produced a structured multi-paragraph explanation: formula definition, a worked Apple/S&P 500 numerical example, an explanation of float-adjusted weighting, and a closing observation about index concentration. Textbook quality. Also 308 tokens more than necessary if you already know what an index fund is.

Caveman Mode (full) — same model, same prompt, .github/copilot-instructions.md active:

Word count:    69 words
Output tokens: 130 tokens  (tiktoken cl100k_base)
Token savings: 70.3%

Actual caveman response:

Market-cap weight = company_market_cap / total_index_market_cap. Apple ~$3T market cap, S&P 500 total ~$45T → Apple weight ~6.7%. $1 invested → $0.067 to Apple. Small company ($5B cap) → 0.011% weight. Stock doubles → index barely moves. Mega-cap ($3T+) → 1% move shifts whole index. S&P 500 float-adjusted: excludes insider/locked shares. Top 10 holdings = 30–35% of index.

Information content: identical. Ceremony: gone. 308 tokens saved on a single conceptual question.

Test Case 2: Python Staircase Pattern (Coding Task)

Vanilla Mode — GitHub Copilot (Claude Sonnet 4.6), no caveman rules:

Word count:    236 words (code + prose)
Output tokens: 354 tokens  (tiktoken cl100k_base)

The code block itself was 4 lines. The remaining 232 words were: a “how it works” walkthrough, time/space complexity analysis, two edge case examples with guarded versions, and a closing paragraph narrating the interview insight.

Caveman Mode (full) — same model, .github/copilot-instructions.md active:

Word count:    58 words (code + prose)
Output tokens: 105 tokens  (tiktoken cl100k_base)
Token savings: 70.3%

Actual caveman response:

def staircase(n):
    for i in range(1, n + 1):
        print(' ' * (n - i) + '#' * i)

Row i: n-i spaces + i hashes → right-aligned to width n. Edge: n≤0 → empty range, nothing prints.

One prose sentence. Zero complexity analysis. The function was correct and complete.

Local Benchmark Summary

Measured on this machine — GitHub Copilot (Claude Sonnet 4.6), 2026-06-12, tiktoken cl100k_base:

Official Benchmark Suite (10-Prompt Average)

The repository’s own benchmarks — run against the live Claude API — provide a more statistically robust signal:

The distribution is instructive. High-explanation prompts (debugging, setup guides, architecture rationale) compress 72–87%. Prompts that are already mostly code (refactor callback to async/await) compress only 22% — because there was not much prose to strip in the first place.

The Thinking Token Distinction

This is the critical nuance that separates caveman from a naive “just tell it to be brief” approach:

Caveman only affects output tokens — thinking/reasoning tokens are untouched.

When Claude reasons through a complex problem, that internal monologue happens in thinking tokens, which are billed separately and not compressed. What caveman compresses is the outbound payload — the text you actually read. This means the model still performs full-depth reasoning; it just stops narrating every step of that reasoning back to you.

The practical implication: caveman does not make the model lazier. It makes the model quieter. There is a meaningful difference.

Scientific Backing

A March 2026 paper — “Brevity Constraints Reverse Performance Hierarchies in Language Models” — found that constraining large models to brief responses improved accuracy by 26 points on certain benchmarks. The counterintuitive finding: verbose output often contains hedging, repetition, and uncertainty signals that reduce confidence calibration. Forcing brevity eliminates noise that was degrading output quality, not adding to it.

Verbose is not always better. Sometimes fewer words mean more correct.

Memory File Compression (/caveman-compress)

Beyond session output, caveman-compress rewrites persistent context files (your CLAUDE.md, project notes, memory files) into compressed form. These savings compound across every session:

A 46% reduction in your context file means 46% fewer input tokens on every single turn, every session, indefinitely. If your CLAUDE.md is 1,000 tokens and you run 50 sessions a month, that is 23,000 input tokens saved per month just from one-time compression.

5. Conclusion & Verdict

Caveman is not a gimmick. It is a focused, well-scoped tool that does one thing — reduces output verbosity — and measures its own impact transparently. The benchmark methodology is honest (it compares against a "be concise" baseline, not against a default verbose mode), the token savings are empirically documented via real API response metadata, and the edge cases are characterized cleanly: low-explanation prompts compress less; explanation-heavy prompts compress dramatically.

Where it wins clearly:

• Debugging and setup guides (72–87% reduction)
• Architectural explanations and concept primers (30–58%)
• Session-level cost tracking via /caveman-stats
• Persistent context compression via /caveman-compress

Where it adds less value:

• Prompts that are already mostly code with minimal prose
• Workflows where you genuinely need step-by-step narration (onboarding docs, tutorials you’re writing)

The real calculus for high-volume developers: At Claude Sonnet pricing, output tokens cost roughly $15/MTok. A developer running 40 meaningful sessions per day generating an average of 792 output tokens per two-prompt interaction (our local measurement) spends approximately $0.48/day on output tokens. With the measured 70.3% reduction, that drops to $0.14/day — a savings of ~$123/year from output tokens alone, before the compounding input-token gains from compressed context files.

That math scales non-linearly as session complexity increases. The prompts in the benchmark that generated 2,347–3,454 vanilla tokens are not outliers in real engineering workflows — they are the median when you are asking an agent to scaffold infrastructure or debug a subtle race condition.

The project’s caveat is worth echoing: the biggest win is readability and speed, not cost. Getting a crisp, dense answer in under a second instead of a 3-second essay changes the cadence of interaction. You stay in flow. That is harder to put a dollar value on, but it is the more honest argument for the tool.

Verdict: Install it. Run /caveman-stats after a week. The numbers will make the argument better than the README does.

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

Caveman — github.com/juliusbrussee/caveman — MIT License. Free like mammoth on open plain.