Making Claude talk like a caveman won't fix your Claude Code bill
The caveman trick went viral because AI coding costs hurt. But output is a tiny slice of the bill. The real cost hides in context, and you can't cut what you can't see.
The caveman trick works on the wrong part of the bill. Telling Claude to answer in short, article-free "caveman" sentences does cut the words it writes back. But in a typical Claude Code session, the words it writes back are a small fraction of what you pay for. Most of the cost is everything sent in: the system prompt, tool definitions, files it reads and the growing conversation it carries along.
The trick going viral tells you something more important than any token count: developers can feel that AI coding is getting expensive, and they don't have the numbers to know why.
Why caveman went viral
The idea is simple and fun. A Claude Code skill tells the model to drop filler and pleasantries and reply like "smart caveman". Developers reported large drops in output tokens, and the story spread from Reddit to mainstream tech coverage.
People didn't share it because they love terse prose. They shared it because their usage limits were running out and their bills were climbing, and this was something they could do about it on their own, today.
Where Claude Code tokens actually go
When analysts looked at the whole bill rather than just the replies, the picture changed. One detailed breakdown estimated that output makes up only 0.6 to 2.5 percent of a typical Claude Code session's billed tokens, which caps the real saving from output tricks at roughly 1 to 3 percent of the bill. The author of the caveman skill has said real-world output savings are "closer to 20–30%", and 20% of a very small slice is still a very small slice.
The rest is input. Every turn of an agentic coding session can resend:
- The system prompt and tool definitions, which can be large on their own
- Files the agent reads, sometimes whole files when a function would do
- Tool results: test output, search results, logs
- The conversation so far, which grows with every step
That's where the money goes. And it's mostly invisible to the developer typing the prompt.
Why this gets worse, not better
Three trends push the input side of the bill up over time:
- Agents do more per task. Coding tools increasingly plan, read, run and retry on their own. Each extra step is another round of context sent to the model.
- Context windows keep growing. Larger windows make it easy to send more, and easy to send more than the task needs.
- Pricing is becoming usage-based. In 2025, Cursor moved to usage-based pricing because "the hardest requests cost far more than simple ones", and Anthropic introduced weekly limits for Claude Code with extra usage available at API rates. The more your team uses, the more it matters how efficiently it uses.
Individual tricks don't add up to a company answer
Caveman, /clear between tasks, smaller files, better prompts: these are all good habits. But they share three limits when you run an engineering team:
- They're invisible. Nobody can tell whether the tricks are working, for whom, or by how much.
- They're uneven. The developers who adopt them are often not the ones driving most of the cost. Usage in AI tools tends to be skewed toward a small group of heavy users.
- They're unconnected to value. A cheaper session that takes three times as many attempts isn't cheaper. Without output measures like merged pull requests, savings can't be judged.
What a team needs is not another trick. It's the ability to see cost by person and team, find the patterns that drive it, and apply savings consistently, without depending on everyone remembering to type the right instruction.
What actually moves the bill
The levers that matter most work on the input side and on behaviour you can measure:
- Prompt caching, so repeated context is billed at a lower rate
- Context discipline: clearing sessions between unrelated tasks, reading only what's needed
- Input compression: removing repeated context and irrelevant material from requests before they reach the model
- The right model for the task, rather than the largest model for everything
- Reclaiming idle seats and watching for runaway sessions
Every one of these is easier with numbers: tokens and cost by person, by team and over time, set against what the work produced.
Why start measuring now
AI coding cost is easiest to understand while it's still small. Start now and you get:
- A baseline, so you can prove a change worked
- Early sight of heavy users and runaway sessions, before they shape the budget
- Data for the "is it worth it?" conversation, which is coming whether you're ready or not
Wait, and the first number you'll see is the invoice.
Where TraceIQ fits
TraceIQ shows what Claude Code and other AI tools cost by person and team, next to what they produced, such as commits and merged pull requests. Its Compact layer works on the input side: it runs on each developer's laptop and trims repeated context and irrelevant material from Claude Code requests before they reach the model, while only counts and costs are reported back. It's the company-wide version of the instinct behind caveman: measured, consistent and aimed at where the tokens really are.
FAQ
Should developers stop using the caveman skill?
No need. It's harmless and can make replies easier to scan. Just don't expect it to change the bill much, because output is a small part of it.
What is the biggest driver of Claude Code cost?
Input: the context sent with every request, including the system prompt, tool definitions, files and tool results, and the growing conversation. That's where caching, context discipline and compression make the biggest difference.
How do we know if our team's AI coding costs are under control?
You should be able to answer, for last month: total cost, cost by person and team, which users or sessions drove most of it, and what was produced in return. If any of those is a guess, start there.
