Caveman Cuts 75% LLM Tokens: Why Smart Devs Ditch Verbose AI

Caveman Cuts 75% LLM Tokens: Why Smart Devs Ditch Verbose AI

Your AI assistant just burned $0.47 explaining a React^{↗ Bright Coding Blog} re-render bug. Seventeen sentences. Three analogies. A "let me walk you through this" that nobody asked for. Meanwhile, your senior dev glanced at the code and grunted: "New object ref. useMemo. Done."

Same fix. One-tenth the words. Zero-tenth the fluff.

What if your AI could channel that senior dev's brutal efficiency? What if every Claude Code response hit like a precision strike instead of a TED Talk? Enter caveman — the open-source Claude Code skill that's making developers everywhere question why they ever tolerated verbose AI output. This isn't about dumbing down. It's about cutting 75% of tokens while keeping 100% technical accuracy. Brain still big. Mouth small.

The cost implications are staggering. At Claude 3.5 Sonnet's output pricing, a team generating 10 million tokens monthly just saved $150. But the real killer feature? Speed. Shorter responses parse faster, iterate faster, ship faster. Let's dig into why caveman isn't just a novelty — it's a fundamental rethink of how we interface with AI coding assistants.

What Is Caveman?

Caveman is a Claude Code skill (also compatible with Codex, Gemini, Cursor, Windsurf, Cline, Copilot, and 30+ other agents) created by Julius Brussee that compresses AI assistant responses into terse, telegraphic "caveman speak." The project's tagline says it all: "why use many token when few token do trick."

Born from a simple observation — that modern LLMs are optimized for helpfulness, which translates to verbosity — caveman inverts the incentive structure. Instead of rewarding word count, it enforces information density. The skill lives in your agent's context window as a behavioral modifier, not a post-processing layer. This matters because it preserves the full reasoning capabilities of the underlying model while eliminating the padding.

The repository has gained rapid traction in the developer tooling community, trending on GitHub as teams discover that token efficiency directly correlates with iteration velocity. Unlike simple "be concise" prompts that models often ignore, caveman uses structured skill files with explicit linguistic constraints — fragment sentences, dropped articles, imperative verbs — that the agent consistently follows.

What's particularly clever: caveman doesn't just compress output. Its caveman-compress sub-skill rewrites your memory files (CLAUDE.md, project notes, todo lists) into the same terse format, cutting ~46% of input tokens every session. This is compound efficiency — smaller context in, smaller responses out, faster everything.

Key Features That Make Caveman Essential

Four Compression Levels

Switch with /caveman [level]. Sticks until session ends.

Beyond Basic Compression

/caveman-commit generates Conventional Commit messages with ≤50 character subjects. Not "feat: add user authentication middleware with JWT token validation" — try "auth: jwt guard, expiry check." Why over what.

/caveman-review delivers one-line PR comments: L42: 🔴 bug: user null. Add guard. No essays. No "great work overall, just one small thing..."

/caveman-stats reads your Claude Code session logs and calculates real token savings + lifetime USD saved. The --share flag generates a tweetable one-liner. Statusline badge shows [CAVEMAN] ⛏ 12.4k — gamified efficiency.

caveman-shrink is MCP middleware that wraps any MCP server and compresses tool descriptions. For teams running 15+ MCP tools, this prevents context bloat at the infrastructure level.

cavecrew-* subagents — investigator, builder, reviewer — operate at ~60% fewer tokens than vanilla agents, extending your main context window's effective lifespan.

Real-World Use Cases Where Caveman Dominates

1. High-Frequency Debugging Loops

You're chasing a race condition. Claude suggests a fix. You try it. It fails. Repeat ten times. With normal verbosity, each cycle costs 400+ output tokens × 10 = 4,000 tokens. Caveman mode: ~100 tokens × 10 = 1,000 tokens. You just bought 3 more debug cycles before hitting context limits.

2. Code Review at Scale

Senior engineers reviewing 20+ PRs daily. Standard AI review: 3 paragraphs per issue. Caveman review: one line. Multiply by 50 issues per PR × 20 PRs. That's not just token savings — it's cognitive bandwidth reclaimed.

3. Memory-Constrained Agents

Claude Code's context window is generous but not infinite. Projects with 100K+ line codebases fill it fast. Caveman-compressed CLAUDE.md files mean more room for actual code in context. The caveman-compress command preserves code blocks, URLs, and paths byte-for-byte — only natural language gets squeezed.

4. Cost-Controlled CI/CD Pipelines

Teams running AI agents in automated build/test loops. Every token is metered. Caveman's 65% average reduction directly translates to 65% lower inference costs for automated workflows. The cavecrew-builder subagent can generate scaffolding at a fraction of the standard token burn.

5. Multilingual Development Teams

The wenyan mode demonstrates that structured brevity transcends language. Classical Chinese's information density isn't just cultural — it's mathematically optimal. Teams working across CJK and Latin scripts report unexpected wins in cross-language consistency.

Step-by-Step Installation & Setup Guide

Prerequisites

• Node.js ≥18 (check with node --version)
• One supported agent installed (Claude Code recommended)
• ~30 seconds of patience

Universal Installer

# 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

The installer auto-detects installed agents and drops skill files for each. Skip agents you don't have — safe to re-run idempotently.

Manual Agent-Specific Setup

For Claude Code, Codex, Gemini: built-in auto-activation. The hook writes a tiny flag file each session — caveman speaks from message one, no /caveman needed.

For Cursor, Windsurf, Cline, Copilot: generates always-on rule files via --with-init flag:

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

For other agents: trigger /caveman per session, or consult INSTALL.md for the full 30+ agent matrix.

OpenClaw Gateway Setup

Running OpenClaw for multi-agent orchestration? Scope to one agent:

# macOS / Linux / WSL
curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash -s -- --only openclaw

# Windows PowerShell without Node: install Node ≥18 first, then
npx -y github:JuliusBrussee/caveman -- --only openclaw

This performs two operations:

1. Skill drop at ~/.openclaw/workspace/skills/caveman/SKILL.md — spec-correct frontmatter (version, always: true)
2. SOUL.md nudge — marker-fenced block appended to ~/.openclaw/workspace/SOUL.md, auto-injected every turn

Custom workspace? Prefix with OPENCLAW_WORKSPACE=/your/path.

Uninstall

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

Skill folder gone, SOUL.md block cleanly removed, other workspace content untouched.

First Activation

/caveman          # default full mode
/caveman ultra    # maximum compression
/caveman-stats    # see your savings

Return to normal: say "normal mode" or restart session.

Real Code Examples From the Repository

Example 1: Before/After React Debugging

The README's canonical comparison demonstrates the core value proposition. Here's the normal verbose output:

🗣️ Normal Claude (69 tokens)

"The reason your React component is re-rendering is likely because 
you're creating a new object reference on each render cycle. When 
you pass an inline object as a prop, React's shallow comparison sees 
it as a different object every time, which triggers a re-render. 
I'd recommend using useMemo to memoize the object."

And caveman's surgical response:

🪨 Caveman Claude (19 tokens)

"New object ref each render. Inline object prop = new ref = re-render. 
Wrap in `useMemo`."

Analysis: The normal response wastes tokens on hedging ("likely because," "I'd recommend") and explanatory scaffolding ("React's shallow comparison sees it as"). Caveman strips to causal chain + fix. The backtick-preserving code formatting ensures useMemo remains actionable. Same technical accuracy, 72% fewer tokens.

Example 2: Authentication Middleware Fix

Normal mode builds rapport before delivering value:

🗣️ Normal Claude

"Sure! I'd be happy to help you with that. The issue you're 
experiencing is most likely caused by your authentication 
middleware not properly validating the token expiry. Let me 
take a look and suggest a fix."

Caveman mode assumes you're here to fix things, not make friends:

🪨 Caveman Claude

"Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"

Analysis: Notice the specific operator correction (< vs <=). This isn't vague hand-waving — it's precise technical diagnosis with the exact fix. The trailing "Fix:" signals code block incoming, maintaining conversational structure without filler. For developers who know their codebase, this is pure signal, zero noise.

Example 3: Installation Script Architecture

The installer's cross-platform support reveals thoughtful engineering:

# 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

Analysis: The -fsSL flags on curl are defensive: -f fail silently on server errors, -s silent mode, -S show errors if it fails, -L follow redirects. The PowerShell irm (Invoke-RestMethod) pipe to iex (Invoke-Expression) is the modern, less-scary successor to the infamous iwr ... | iex pattern. Both scripts are hosted directly from GitHub raw, ensuring version transparency and auditability.

Example 4: OpenClaw SOUL.md Injection Pattern

The marker-fenced block for persistent activation:

~/.openclaw/workspace/
├── skills/caveman/SKILL.md   ← full ruleset, on-demand load
└── SOUL.md                    ← <!-- caveman-begin --> ... <!-- caveman-end -->
                                  ↑ auto-inject every turn

Analysis: This architecture is brilliantly non-destructive. The HTML-style comment markers (<!-- caveman-begin/end -->) ensure that even if SOUL.md is parsed as markdown^{↗ Smart Converter}, the boundaries are invisible. The skill file lives separately for on-demand loading, while the SOUL.md nudge guarantees every turn starts with caveman context — no per-session /caveman invocation needed. The 12K-per-file, 60K total SOUL.md budget means the caveman block is negligible overhead for massive context savings.

Example 5: Benchmark Harness Transparency

The evaluation methodology from evals/:

Three-arm eval harness (baseline / terse / skill) lives in evals/ 
— caveman compared against "Answer concisely." not against verbose 
default, so the delta is honest.

Analysis: This methodological rigor separates caveman from snake oil. By comparing against "Answer concisely." rather than the unmodified verbose default, the 65% figure is conservative and reproducible. The three-arm design (baseline, simple terse prompt, full caveman skill) isolates the skill's structured constraints from generic brevity requests. The raw data and reproduction script in benchmarks/ invite independent verification.

Advanced Usage & Best Practices

Compose the Ecosystem

Caveman works synergistically with its sibling projects:

cavekit drive build    → spec-driven, no guessing
caveman compress say   → minimal token output
cavemem compress remember → persistent cross-agent memory

This three-rock stack addresses the complete agent lifecycle: planning, execution, and memory.

Session-Level Optimization

For maximum efficiency, run caveman-compress on your memory files before starting intensive sessions:

/caveman-compress CLAUDE.md
/caveman-compress project-notes.md

This compounds: 46% smaller input context + 65% smaller outputs = ~3× effective context window extension.

MCP Server Bloat Prevention

If you're running 10+ MCP servers, caveman-shrink middleware prevents tool description bloat:

npm install -g caveman-shrink
# Wrap any MCP server, compress descriptions transparently

Team Rollout Strategy

Start with lite mode for team adoption — less jarring than full. Migrate to full after one sprint. Power users can experiment with ultra for known-codebase work. The wenyan mode is primarily for demonstration; unless your team reads classical Chinese, it's a compression theory proof.

Monitoring Savings

Set a recurring /caveman-stats --share in your standup notes. Visibility drives adoption. The statusline badge provides ambient awareness — when [CAVEMAN] ⛏ 50k appears, the skill has paid for itself many times over.

Comparison With Alternatives

Why caveman wins: Unlike "be concise" prompts that models habitually ignore, caveman's structured skill files with explicit linguistic rules create consistent behavioral modification. Unlike post-processors, there's no risk of summarization artifacts — the model generates terse output natively. Unlike fine-tuning, it's free, instant, and reversible.

The March 2026 paper "Brevity Constraints Reverse Performance Hierarchies in Language Models" (arXiv:2604.00025) provides academic backing: constraining models to brief responses improved accuracy by 26 points on certain benchmarks. Verbosity isn't just expensive — it's sometimes genuinely worse.

FAQ

Q: Does caveman reduce the quality of technical explanations? A: No. The benchmarks show 100% technical accuracy preservation. Caveman only removes filler — hedging, pleasantries, redundant explanations. The March 2026 arXiv paper even suggests brevity constraints can improve accuracy.

Q: Which AI agents support caveman? A: Claude Code (built-in auto-activate), Codex, Gemini, Cursor, Windsurf, Cline, Copilot, OpenClaw, and 30+ others. Full matrix in INSTALL.md.

Q: Can I use caveman for non-coding tasks? A: Yes, though optimized for technical contexts. The compression principles apply universally — caveman-compress works on any markdown file.

Q: Is my data sent to external servers? A: No. Caveman is a local skill file. The installer downloads from GitHub raw, but all processing happens on your machine. No telemetry, no API keys, no cloud dependency.

Q: How do I uninstall completely? A: Re-run the installer with --uninstall flag. Removes all skill files and SOUL.md markers cleanly. Your other workspace content is untouched.

Q: What's the difference between lite, full, ultra, and wenyan? A: lite drops filler words; full is default telegraphic style; ultra is maximum compression for known contexts; wenyan uses classical Chinese for theoretical minimum token count.

Q: Does caveman affect thinking/reasoning tokens? A: No. Caveman only compresses output tokens — the model's internal reasoning remains untouched. This is why accuracy stays intact.

Conclusion

We've been trained to accept verbose AI output as "helpful." But helpfulness isn't word count — it's signal-to-noise ratio. Caveman proves that with the right constraints, LLMs deliver crisper, faster, better responses at a fraction of the cost.

The 65% token reduction isn't a party trick. It's compound efficiency: lower inference costs, faster parsing, extended effective context windows, and — counterintuitively — potentially higher accuracy. In a world where context is currency, caveman is arbitrage.

Julius Brussee has built something deceptively simple yet architecturally sophisticated. The skill file approach, the SOUL.md injection pattern, the MCP middleware, the three-rock ecosystem — this is systems thinking applied to AI interaction design.

Stop paying for AI pleasantries. Your codebase doesn't need "I'd be happy to help." It needs fixes. Install caveman. Talk less. Ship more.

⭐ Star caveman on GitHub — it costs zero tokens, and the savings start immediately.

Caveman save you token, save you money. Star cost zero. Fair trade. 🪨