caveman: make the AI shut up and just say the thing
The AI prefaces every answer with three lines of throat-clearing. caveman is a 50-line prompt that cuts all of it and keeps the technical content intact. I measured three languages — English drops about 63%.
github.com/mattpocock/skills @2bf7005 1. The AI’s pleasantries are a tax you pay every single day
You pair-program with an AI, dozens of turns a day. What grinds you down most?
It’s not that the model can’t code. It’s that every answer opens with three lines of warm-up:
Absolutely! I’d be happy to help with that. The issue you’re running into is most likely caused by…
The only useful part is the last sentence. Everything before it is filler.
And that filler isn’t just tiring to read. It burns tokens, slows the response, and quietly fills up your context window — the longer the session runs, the more of this “pleasantry tax” you pay. None of which you ever asked for.
What caveman does fits in one line: it makes the AI talk like a smart caveman. Technical content stays whole. The pleasantries, the warm-up, the hedging that never commits to anything — gone.
It’s the smallest skill in Matt Pocock’s collection — the whole file is 50 lines. But install it, use it once, and you probably won’t go back.
2. There’s no trick to it: a “shut up, just say it” agreement
You might assume there’s some clever machinery behind this. There isn’t. The entire SKILL.md for caveman is an agreement about reply style, and it comes down to three things:
What gets cut. Out go the empty intensifiers (actually, basically, in short), the courtesies (of course, I’d be happy to), and the weasel words that hedge instead of committing. If one word does the job, don’t spend a sentence on it. Causation gets an arrow: X -> Y.
But there’s one red line, and it’s in bold for a reason:
Technical terms stay. Code blocks stay verbatim. Error messages are not touched.
In other words, it cuts the fluff, not the information. This is nothing like barking “just keep it short” at the model — that kind of crude compression throws useful detail out with the bathwater. caveman doesn’t.
Once it’s on, it stays on (the skill calls this Persistence). It won’t quietly drift back to verbose after a few turns. Until you call it off, it keeps talking this way.
When things get dangerous, it switches itself back to normal (the skill calls this the Auto-Clarity exception). Hit a destructive command, an irreversible operation, or something that genuinely needs several steps to explain, and it temporarily restores full prose to spell it out — then flips back.
That third rule is where caveman is smarter than “just be terse no matter what”: it saves tokens without cutting corners where corners matter. That sense of proportion is deliberate. Sit with it for a second.
3. Three steps, and you’ll see the difference immediately
Enough talk. Install it and watch the before/after yourself.
Install. It’s one skill inside mattpocock/skills. Use the official one-liner and tick caveman when prompted:
npx skills@latest add mattpocock/skills(If you’ve already cloned the repo locally, you can also just copy that directory into your project’s .claude/skills/.)
Turn it on. Tell Claude Code caveman mode, or type /caveman. Done with it? Say normal mode.
Compare. Ask it the same question both ways — say, “Why does my React component re-render every time its parent renders?”
Normally you’d get three or four paragraphs: default behavior, React.memo, useMemo/useCallback, children, and a closing reminder not to optimize prematurely. In caveman mode, you get this (real output, not something I made up):
Default behavior. Parent renders -> child renders, whether props changed or not.
Three ways to kill re-renders:
React.memo(Child)-> shallow-compares props, skips if unchanged- Objects/arrays/functions passed to the child: wrap in
useMemo/useCallback, else new reference each time -> memo breaks- Lift state down so the parent doesn’t render on unrelated state changes
Debug: install React DevTools Profiler, see who renders and why.
React.memo, shallow comparison, stable references, lifting state, the Profiler — not a single point dropped. But you finished reading it in one glance.
That’s your first real result. Don’t take my word for it; run it once and you’ll believe it.
4. I did the math for you: ~63% in English, but it depends on the language
caveman’s own description claims it “saves about 75% of tokens.”
But that’s the author’s self-reported number with no method attached. Take it as a rumor — what someone else claims they saved doesn’t count; you have to measure it yourself.
So I did, and I tested three languages. I picked 6 questions a developer would actually ask off the cuff (React re-renders, connection pools, Node memory leaks, async/await, undoing a git commit, JWT vs sessions), had the AI answer each in normal mode and in caveman mode, and counted characters. The baseline was a real, un-padded answer — not a strawman puffed up to flatter the result.
Here’s what came out:
| Language (its own normal vs caveman) | Character reduction |
|---|---|
| English | ~63% |
| Chinese | ~70% |
| Japanese | ~52% |
Call it roughly two-thirds, three-quarters, and a half — all substantial, with no information lost. But notice this: the reduction varies a lot by language. Chinese carries the most courtesy phrases and filler, so there’s more water to wring out; Japanese is fairly compact even in normal mode, so caveman has less to squeeze. So “saves 75%” can’t be a one-size-fits-all slogan — it depends on the language you’re working in.
Method on the table, no false precision: I used non-whitespace character count as a proxy, not exact token count (the test environment had no tokenizer installed). Within a single language the character ratio tracks the token ratio closely enough, so the per-language reduction is trustworthy; across languages the raw character counts aren’t comparable, so I’m reporting each language’s reduction against itself. Sample is just 6 questions — enough to give you a sense of the order of magnitude.
One more thing the numbers turned up, worth flagging: caveman has a default pull toward terse English. It was designed in English, so when you work in English none of this bites you — but ask it something in another language and it tends to snap right back to clipped English replies. If English is your working language this is a non-issue; if it isn’t, pin the language when you turn caveman on. (My first multilingual run didn’t pin the language down, so the Chinese and Japanese numbers got contaminated by a “switched to English” effect — not clean. Pinning the language and re-measuring gave me the table above.)
5. But don’t leave it on all day — it has a temperament
caveman is genuinely useful, but it’s not a “flip it once and forget it” switch. A few things to get straight first:
- It drifts to English (covered above). Working in English? Ignore this. Working in another language? Pin it when you turn caveman on, or your replies will keep snapping back to English.
- Lots of fragments, low margin for error. It drops connectives and leans on short, clipped phrases. The information density is high, but lose focus for a second and it’s easy to misread. So: anything meant for someone else’s eyes, any formal doc you’re going to ship, any complex multi-step reasoning — leave caveman off. In those situations, “being clear” beats “saving tokens” by a mile. (Auto-Clarity does restore full prose for dangerous and multi-step cases, but keep this straight in your head: it’s built for you and the AI talking fast, not for the AI writing for someone else.)
- It’s a style, not a capability. caveman won’t get one extra thing done for you; it only changes how the AI talks to you. Treat it as a permanent “low-bandwidth mode” and don’t expect it to run some workflow on your behalf.
In one line: turn it on while you’re talking, turn it off when you need real output. Get that bit of judgment right and it stays a good tool.
6. Cheat sheet
Install: npx skills@latest add mattpocock/skills # tick caveman at the prompt
On: tell the AI "caveman mode" or /caveman
Off: "normal mode" / "stop caveman"
Language: working in English? fine. otherwise pin your language when turning it on, or it drifts to English
Cut: empty intensifiers (actually/basically), courtesies (I'd be happy to), hedging
Keep: technical terms, code blocks, raw error messages — untouched
Causation: use an arrow X -> Y
Exception: dangerous ops / multi-step -> auto-restores full prose (Auto-Clarity)
Don't use: formal docs / tutorials / anything for someone else -> turn it off
Measured: English ~63%, Chinese ~70%, Japanese ~52% (author self-reports ~75%)7. Further reading
- The skill’s source: mattpocock/skills · caveman (MIT licensed)
- Like this “one prompt rewires the AI’s behavior” trick? Matt’s repo is full of them, and this series will keep taking them apart.
- Want to talk these skills over with Matt himself and tens of thousands of other developers? His newsletter is the place.
This is original teaching content from usesuperpowers.com. The caveman skill it covers comes from mattpocock/skills (
source_commit: 2bf7005), used under its MIT license. The original skill’s rules remain the copyright of their author; our breakdown, measurements, and writing are original.