Caveman LLM: token savings up to 87%

Caveman-Style LLM Responses: Slash Token Usage by Up to 87%

Developers found that forcing LLMs into caveman style—short phrases, no articles, no politeness, no fluff—cuts output tokens by 65% on average. For tasks like debugging React bugs or configuring PostgreSQL, savings hit 87%. This keeps accuracy and technical details intact, stripping only verbal padding.

React re-render example (standard response: 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.

Caveman style (19 tokens):

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

What Gets Cut and What Stays

RLHF makes modern models wordy: "Sure, happy to help," "Let's break it down step by step." Caveman style filters that out, zeroing in on the core.

| Element | Action |

|---------|----------|

| Explanations | Cuts fluff, keeps essence |

| Code blocks | Untouched |

| Tech terms | Preserved (polymorphism stays polymorphism) |

| Articles (a/an/the) | Removed |

| Politeness | Removed |

| Hedging phrases | Removed |

Token-wasting phrases:

• "I'd be happy to help you with that" — 8 tokens
• "The reason this is happening is because" — 7 tokens
• "I would recommend that you consider" — 7 tokens
• "Sure, let me take a look at that for you" — 10 tokens

Performance Benchmarks

Claude API tests show savings from 22% to 87%:

| Task | Standard (tokens) | Caveman (tokens) | Savings |

|--------|-------------------|-------------------|----------|

| React re-render bug | 1180 | 159 | 87% |

| Auth middleware fix | 704 | 121 | 83% |

| PostgreSQL pool | 2347 | 380 | 84% |

| git rebase vs merge | 702 | 292 | 58% |

| Callback → async/await | 387 | 301 | 22% |

| Microservices vs monolith | 446 | 310 | 30% |

| PR security review | 678 | 398 | 41% |

| Docker multi-stage | 1042 | 290 | 72% |

| PostgreSQL race condition | 1200 | 232 | 81% |

| React error boundary | 3454 | 456 | 87% |

Average: 1214 → 294 tokens, 65% savings. Bigger wins on explanatory tasks.

A 2026 study confirms: brevity boosts accuracy by 26 percentage points in benchmarks—models avoid hallucinations from extra words.

Caveman Levels

• Lite: No fluff, still readable.

Your component re-renders because you create a new object reference each render. Inline object props fail shallow comparison every time. Wrap it in useMemo.

• Full: Short phrases.

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

• Ultra: Max compression.

Inline obj prop → new ref → re-render. useMemo.

Input Token Compression

Caveman Compress rewrites memory files (CLAUDE.md) in caveman style for Claude Code. Command:

/caveman-compress CLAUDE.md

Result: compressed CLAUDE.md (for the model) + original (for editing).

| File | Before (tokens) | After (tokens) | Savings |

|------|--------------|-----------------|----------|

| claude-md-preferences.md | 706 | 285 | 59.6% |

| project-notes.md | 1145 | 535 | 53.3% |

| claude-md-project.md | 1122 | 687 | 38.8% |

| todo-list.md | 627 | 388 | 38.1% |

| mixed-with-code.md | 888 | 574 | 35.4% |

Average: 45% savings. Pairs with caveman for input/output optimization.

Key Takeaways

• Output token savings: 65% average, up to 87% on complex explanations.
• Technical accuracy preserved: code, terms, errors unchanged.
• Three modes from Lite to Ultra for balancing brevity and readability.
• Input file compression: 45% on CLAUDE.md and similar.
• Research-backed: brevity lifts accuracy by 26 percentage points.

— Editorial Team