# Caveman Skill and Proxy: Cut 65% Claude Tokens [2026]

> The viral caveman skill and proxy strips Claude Code's output down to telegraphic text and claims a 65% token cut. Here's how it works, the real savings math, and whether terse responses quietly wreck your code.

- Canonical: https://www.kunalganglani.com/blog/caveman-skill-claude-code-tokens
- Author: Kunal Ganglani
- Published: 2026-10-14 · Updated: 2026-10-14
- Category: Technology · Tags: claude-code, ai-coding-assistants, token-optimization, prompt-compression, ai-agents

## TL;DR

The caveman skill is a viral trick that forces a coding agent like Claude Code to answer in short, grammar-free "caveman" sentences so it uses fewer words and costs less. Fans claim it cuts token usage by about 65%. It works because most of what an AI agent writes is padding that no human ever reads, and padding is what you pay for. The catch is that terse replies can wreck commit messages, code reviews, and explanations. The smart move is to compress the chatter between machines and keep the human-facing text readable. Pair it with cheaper models and better context habits and the savings stack.

The caveman skill is a prompt-compression trick packaged as a Claude Code skill plus a request/response-rewriting proxy that forces a coding agent to answer in stripped-down, telegraphic language. No articles, no filler, no restated context. The viral version claims a 65% token reduction on agentic coding workloads. Most people hear that and assume the answers get worse. They mostly don't, and that's the interesting part.

The timing isn't an accident. On September 14, 2026, Anthropic rolled Claude Code's weekly usage allotment back from a temporary summer promotion of 150% to a permanent 125%. Developers on r/ClaudeAI felt that as a 17% cut overnight, and the whole token-saving cottage industry, caveman included, exploded in the weeks after.

**Key takeaways:**

- The caveman skill started as a Reddit prompt-hack that told Claude to "talk like a caveman," and a viral short put the chat-only savings near 75%.
- The coding-agent version claims a more conservative 65%, because code output compresses less cleanly than prose.
- In a month-long audit of 455 Claude Code sessions, subagents alone ate 48.1% of all tokens and wrote 64% of output. That's exactly what caveman targets.
- Model routing (Claude Haiku 5.5 at $0.10 per million input tokens, roughly 20x cheaper than Sonnet) is a parallel lever, not a competitor.
- Terse personas carry a real cost in review clarity and commit-message quality, and nobody selling the trick talks about that.
## What the caveman skill and proxy actually do

The caveman skill is really two parts doing one job. The skill component sits inside Claude Code and rewrites the system-level instruction so the model's responses drop everything a human reader would call "polish." The proxy component intercepts requests and responses on the wire and rewrites them before they count against your token meter.

![Lines of colorful JavaScript code displayed on a dark screen](https://cdn.sanity.io/images/vzekdneq/production/c955d26de8fdb0429f885023f8c4ab5de0a88174-1200x675.webp)

Take the difference between "I will now update the authentication middleware to validate the JWT signature before parsing the payload, which prevents a malformed token from reaching the handler" and "Update auth middleware. Validate JWT sig before parse. Blocks bad token early." Same instruction. Roughly half the output tokens. Multiply that across every turn in a long agent loop and the compounding is where the 65% figure comes from.

The origin is pure internet. A Reddit user noticed that telling Claude to answer in "caveman speak" collapsed its verbosity, and [Varun Mayya](https://www.youtube.com/watch?v=UmndOsL9ASc) amplified it in a short that pegged the chat savings at "almost 75% tokens." That number is real for open-ended chat, where the model loves to restate your question and wrap advice in three paragraphs of hedging.

> Caveman mode works because most of an agent's output is social lubrication for a human who never reads it.

Code is a harder target. You can't caveman-speak a function body. So the skill compresses the connective tissue around the code: the explanations, the plans, the "here's what I did and why," while leaving the actual diffs intact. That's why the coding-specific packaging lands at 65% rather than 75%, and I'd trust the lower number more. When I built the [LLM cost](/blog/ai-agent-cost-per-task-2026) calculators on this site, the recurring lesson was that per-token price comparisons mislead without a workload shape attached. Caveman's savings depend entirely on how much of your workload is prose versus code.

## Why coding agents bleed tokens in the first place

To see why a verbosity hack matters, you have to look at where the tokens actually go. The answer is not your prompts.

![JavaScript code displayed on a dark screen with colorful syntax highlighting](https://cdn.sanity.io/images/vzekdneq/production/1b98f11a4dc52f48e669aa24dbd26367ad92d7a2-1200x675.webp)

[AI Dive](https://aidive.dev) ran a month-long log audit that should be mandatory reading for anyone optimizing [Claude Code](/blog/opencode-vs-claude-code-token-overhead): 455 sessions, 63,000 requests, 9.3 billion tokens after de-duplicating the roughly 1.96 log lines written per request. The headline finding is brutal. Subagents, the helpers you spin up to parallelize work, consumed 48.1% of all tokens and wrote 64% of all output. That is a bigger line on the meter than the human typing.

Worse, every subagent pays an entry fee before it does anything useful. The audit measured a median of 47,117 tokens on a subagent's opening request alone, because the full instruction set, tool list, and skill list get resent on every launch. Your carefully trimmed agent file is, as the author put it, a rounding error inside its own startup cost.

This is the exact surface caveman attacks. The skill list resent 2,631 times across that month is verbose boilerplate. The subagent's output, that 64% slice, is where telegraphic responses claw back the most. If subagents are the fire, caveman is aimed directly at the fuel.

Verbosity also poisons context quality, not just cost. [Igor Irianto](https://irian.to) catalogued four Claude Code context antipatterns, including the "correction rabbit hole" where ten rounds of "no, make it smaller" pile up as noise the model has to re-read every turn. Compressed responses mean each of those turns burns fewer tokens and leaves a cleaner context window behind. Measuring that overhead precisely is its own discipline, one I dug into when writing about [AI coding agent harness overhead](/blog/ai-coding-agent-harness-overhead-measurement).

## Caveman vs model routing: the third lever

The token-saving world had split into two camps before caveman showed up, and understanding both is how you decide whether the caveman skill and proxy are worth running.

![a computer screen with a bunch of words on it](https://cdn.sanity.io/images/vzekdneq/production/a89b443b52ed3bf9c08444533a3d59a3c04bc7ce-1200x675.webp)

Camp one is context hygiene: clear your context between tasks, stop overstuffing `CLAUDE.md`, kill long Marco-Polo sessions. Camp two is model routing: stop sending everything to the expensive model. Claude Haiku 5.5 lands at $0.10 per million input tokens, roughly 20x cheaper than Sonnet, and frameworks like the "Checkability Rule" exist specifically to decide which subagent calls are safe to downgrade. A subagent running a test suite and reporting pass/fail does not need a frontier model.

Caveman is the third lever: response compression. It's orthogonal to the other two. Here's how the three stack up at a glance:

| Lever | What it lowers | Cost to adopt | Main risk |
| --- | --- | --- | --- |
| Context hygiene | How often tokens get resent | Free (habit change) | Easy to forget mid-session |
| Model routing (Haiku 5.5) | Price per token (~20x on input) | One config change | Wrong model on a hard task |
| Caveman skill + proxy | Number of output tokens (~65%) | Skill plus proxy setup | Lost review and commit clarity |

You can route a subagent to Haiku, clear your context, *and* run caveman mode, and the savings stack because they attack different quantities. Routing lowers the price per token. Caveman lowers the number of tokens. Hygiene lowers how often you resend them.

Based on the live model pricing I maintain at [kunalganglani.com/llm-prices](/llm-prices), output tokens routinely bill at three to five times the input rate across frontier models, which is the strongest argument for caveman over pure routing. [Simon Willison](https://simonwillison.net), who tracks LLM pricing more closely than almost anyone, keeps pointing out that output tokens are where agent costs quietly accumulate. Routing a subagent to Haiku still lets it write 64% of your output in full sentences. Caveman cuts the output itself.

If I had to sequence these on a real team, I'd do hygiene first because it's free, routing second because it's a config change, and caveman third because it changes how your agent communicates. Running this blog's own multi-agent pipeline taught me that model-per-job-shape, Sonnet for tool loops and Opus for prose, beats one-model-everywhere on both cost and quality. Caveman is the same instinct applied to verbosity instead of model choice.

## Does caveman speak break your code?

Here's the thing nobody selling the trick says out loud: terse output is not free. You're trading tokens for legibility, and sometimes legibility is the product.

The code itself is fine. A diff is a diff whether the model narrates it in Shakespearean English or grunts. The risk lives in everything *around* the code:

1. **Commit messages** turn into fragments. "Fix auth bug" is cheaper than a conventional-commit body, but your git history is documentation your future self reads under pressure.
1. **Code review explanations** lose the "why." When an agent explains a non-obvious change in four words, a human reviewer can't evaluate the reasoning, only the result.
1. **Plan quality** can degrade. Some of Claude's accuracy on complex refactors comes from "thinking out loud" in its response. Compress that away and you may be compressing the reasoning that produced the right answer.
1. **Debugging handoffs** suffer. When a run fails and you read the transcript, telegraphic logs are harder to reconstruct than verbose ones.
1. **Onboarding** gets worse. A junior watching an agent work learns from the narration. Caveman mode removes the teaching.
The rule that holds up across teams running agent workflows is simple: compress the machine-to-machine traffic, keep the human-facing output readable. Caveman is excellent for subagent chatter that no person ever reads. It's a bad idea for the final commit, the PR description, or the explanation you're about to paste into a ticket. The proxy approach helps here, because you can scope the rewriting to subagent requests and leave top-level responses alone. That's the configuration I'd trust. A blanket "everything talks like a caveman" setting is how you end up with a clean token bill and a repository nobody can read in six months.

## How to test the caveman skill before you trust it

Before you wire a verbosity proxy into a production coding loop, run a controlled test. The 65% figure is a claim, not a measurement of your workload, and the only honest way to know your savings is to generate them yourself.

1. **Baseline a real task.** Pick a representative session, a multi-file refactor with some subagent fan-out, and record total input and output tokens from the Claude Code logs before you change anything. Use the median subagent entry cost of 47,117 tokens from the AI Dive audit as a sanity check that your numbers land in a plausible range.
1. **Apply caveman to subagents first.** Scope the proxy rewrite to subagent requests, the 64% of output that no human reads, and leave top-level responses in full English. Re-run the same task so you're comparing like for like.
1. **Diff the token counts, not the vibes.** Compare output tokens before and after. If you see less than a 30% drop, your workload is code-heavy and caveman is the wrong lever. Reach for [model routing](/blog/opencode-vs-claude-code-token-overhead) or context hygiene instead.
1. **Read the artifacts.** Open the commit messages, the PR body, and any explanation the agent produced. If a teammate can't understand the change from those alone, you compressed too aggressively and should pull the scope back.
1. **Repeat under load.** Verbosity savings that look great on one task swing wildly across a week of mixed work. Run the test over several sessions, with different task shapes, before you commit it to the whole team.
The discipline matters more than the trick. Per-token savings claims mislead without a workload shape attached, which is the same lesson that shaped this site's [AI Agent Cost Per Task](/blog/ai-agent-cost-per-task-2026) math and its [prompt compression benchmark](/blog/prompt-compression-token-savings-benchmark). A viral 65% is a hypothesis. Your logs are the experiment. Measure caveman the way you'd measure any other change to [production AI](/pillars/ai-engineering-production): against a real session, not a demo.

## Should you actually run the caveman skill?

The honest answer depends on your workload shape, and I mean that literally. If your Claude Code usage is prose-heavy, long planning sessions, lots of explanation, heavy subagent fan-out, caveman could genuinely recover a double-digit percentage of your weekly limit. If you mostly do tight, single-file edits with little subagent activity, the 65% claim won't translate, because there's little prose to compress.

Based on the traffic data I track for this site, this topic is not a fad. "ai-coding-assistants" is the single largest subtopic in my [Dev Tools & AI Workflow](/pillars/developer-tools-workflow) pillar, 30 posts pulling 44,264 impressions over 90 days, and the `claude-code` tag runs a median of 1,021 impressions per post with an 80% page-one rate. Developers are searching for exactly this, which tells you the September cut hit a nerve and the demand for token-saving tricks is structural, not seasonal.

One caveat worth stating plainly: despite a lot of searching, I could not retrieve an independently verifiable GitHub repo, launch post, or named author for the specific caveman skill-plus-proxy project. The underlying technique is real and reproducible, you can test it in one prompt. The packaged tool is harder to pin down, so treat vendor-specific numbers with the skepticism any viral claim deserves, and measure your own before and after. If you want the broader map of how these tricks fit together, my writing on [AI agents](/pillars/ai-agents) and [agentic AI](/blog/rise-of-agentic-ai) in production covers the cost surface in more depth.

The real skill here isn't talking like a caveman. It's knowing which 65% of your agent's words were never load-bearing in the first place. The tools that win in 2026 will be the ones that drop that 65% automatically, scoped to exactly the traffic no human reads, while leaving the words that matter intact. If you build [production AI](/pillars/ai-engineering-production) systems, that distinction, signal versus social lubrication, is about to become a line item on every invoice. Learn to draw it yourself before a proxy draws it badly for you. The patterns I lean on for this live in my [prompt engineering](/blog/prompt-engineering-patterns-that-changed-how-i-ship) playbook and the [concepts for coding with AI agents](/blog/concepts-coding-ai-agents) breakdown.

Photo by Bernd 📷 Dittrich on Unsplash.

## FAQ

### What is the caveman skill for Claude Code?

It is a prompt-compression setup, usually a Claude Code skill paired with a proxy, that instructs the model to reply in stripped-down, telegraphic "caveman" language with no articles or filler. The goal is to cut output tokens, which are the most expensive part of an agent's work, while leaving the actual code untouched.

### Does the caveman technique really save 65% of tokens?

The 65% figure applies to coding workloads and is more conservative than the roughly 75% claimed for open-ended chat, because code itself does not compress. The savings come from shrinking the explanations, plans, and restated context around the code. Your actual result depends on how prose-heavy your sessions are, so measure before and after.

### Is the caveman skill better than switching to Haiku 5.5?

They solve different problems, so use both. Model routing to Claude Haiku 5.5, priced around $0.10 per million input tokens and roughly 20x cheaper than Sonnet, lowers the price per token. Caveman lowers how many tokens get written. Stacking routing, context hygiene, and compression saves more than any single lever.

### Will caveman mode make Claude write worse code?

The code is usually fine because a diff is a diff regardless of narration. The damage shows up around the code: vague commit messages, thin code-review explanations, and weaker debugging transcripts. The safe pattern is to compress only subagent and machine-to-machine traffic and keep final commits and PR descriptions in full English.

### Why did Claude Code token usage become such a big topic in 2026?

On September 14, 2026, Anthropic rolled Claude Code's weekly allotment back from a summer promotion of 150% to a permanent 125%, which developers experienced as a 17% cut. A log audit then showed subagents alone consume 48.1% of tokens, so the community rushed to find savings like model routing and the caveman skill.