Caveman v4.0: From "Caveman Speech" to a Six-Rock Token Optimization System
> Project: JuliusBrussee/caveman > Repository: https://github.com/JuliusBrussee/caveman > Language: Go | +530 stars today | #1 on Hacker News
1. A "Joke" Cited by Adobe
In April 2026, a project called caveman hit #1 on Hacker News. Its slogan:
> "why use many token when few token do trick"
It sounds like a meme. But five months later, Adobe Research cited caveman's methods in a paper, reporting 1.4-2.4x average cost savings across 8 models. JetBrains ran A/B tests: 8.5% output token reduction with no significant quality difference (p=0.82). Elasticsearch Labs rebuilt a version based on caveman's methods.
Why would a "caveman speech" joke be taken seriously by Adobe and JetBrains?
2. Core Insight: The Model Isn't "Thinking" — It's "Translating"
Caveman's first rock is Say less: it compresses agent output from full English paragraphs into controlled English.
Instead of:
> "The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle... I'd recommend using useMemo to memoize the object."
Caveman produces:
> "New object ref each render, so React re-renders. Wrap the prop in useMemo."
63 tokens become 20. Same answer, same fix.
The key insight: most of a model's output is not "thinking" — it's "linguistic packaging." The real information is "new object reference causes re-render, wrap in useMemo," but the model habitually adds connectives and pleasantries. Caveman doesn't break grammar; it strips packaging, leaving only the informational core.
3. ASD-STE100: Lessons from Aircraft Maintenance Manuals
Caveman's design inspiration is ASD-STE100 (Simplified Technical English) — the controlled English used in aerospace maintenance manuals, where one word has one meaning, sentences stay under 20 words, no passive voice, no metaphors. Ambiguity is dangerous at 30,000 feet.
Caveman applies the same principles to AI output. "I'd recommend using useMemo" and "useMemo" are informationally equivalent, but the former costs 4 extra tokens. In aviation, controlled English serves safety; in AI agents, it serves token efficiency. Same principle (controlling language complexity), different problem domain.
4. The v4.0 Six-Pack: From Single Tool to System
| Rock | What it does | Effect | |------|-------------|--------| | Say less | Compress output language | 63→20 tokens | | Read less | Compress input files (CSV/logs/YAML) | 28k→314 tokens (98.9%) | | Auto | Auto-select models | 54% cost reduction | | Blocks | Reuse previous code blocks | 397→76 tokens | | Waste fixes | Identify and skip ineffective fixes | Less idle spinning | | Browse | Compress web content | 129.8x size reduction |
The most notable is Read less. An agent reading a 28,000-line CSV originally burns 28,000 tokens; caveman compresses it into a 314-token structured summary (column names, types, samples, statistics), and the agent can still answer questions about the file.
This solves a fundamental problem: an agent doesn't need the full file — it needs the file's "structure." Asking "does this CSV have null values" doesn't require reading every row, only schema and null statistics.
5. Auto: Letting Models Pick Models
Auto routes tasks by difficulty:
- Simple tasks (formatting JSON) → Haiku (cheap)
- Medium tasks (writing a React component) → Sonnet
- Hard tasks (debugging concurrency) → Opus (expensive but strong)
- Say less → output language redundancy
- Read less → input file redundancy
- Auto → model selection redundancy
- Blocks → repeated output redundancy
- Waste fixes → wasted-attempt redundancy
- Browse → web content redundancy
- Repository: https://github.com/JuliusBrussee/caveman
- Homepage: https://caveman.so
- Adobe Research citation: see caveman homepage
Caveman tested 85 coding tasks: Auto mode was 54% cheaper than always using Opus, with equal answer quality.
Most coding task difficulty is long-tailed — 80% simple, 20% hard. Always paying for the most expensive model wastes money on the easy 80%. Auto works like a good project manager: junior engineers get easy work, senior engineers get the hard stuff.
6. "Your Prompts Stay Yours": A Counterintuitive Design
Caveman never compresses your input prompts — only agent output. If you compress prompts into caveman style, answer quality degrades.
Why? Models are trained on complete prompts; a compressed prompt falls outside the training distribution. But output doesn't need to be complete — output is generated, not understood, so compressing it doesn't hurt comprehension.
The subtle distinction: inputs should be complete (matching the training distribution), outputs should be lean (information only). Many token-optimization tools get this wrong and compress inputs too, degrading quality.
7. Blocks: The Right Way to Reuse Code
Blocks addresses agents repeatedly generating identical code. When an agent runs tests 5 times with 90% identical code, caveman outputs the full code once and only diffs afterward: 397 tokens become 76. This isn't compression — it's deduplication, like git storing full files on first commit and diffs afterward.
8. Why This Matters More Than It Looks
Caveman reveals a deeper insight: AI agent output contains massive "structural redundancy." The model's internal reasoning is efficient (vector operations); the inefficiency is in translating reasoning into grammatical natural language.
Each of the six rocks targets a different redundancy:
This isn't a compression tool — it's a taxonomy of token redundancy. That's why Adobe and JetBrains studied it seriously: once you identify where redundancy lives, compression follows naturally.
---
Links