Topic: AI agents
Caveman: Terse AI Agents, Same Accuracy
A bilingual blog post based on the JuliusBrussee/caveman README, covering what the project does, why it matters, and where terse AI responses actually help.
Animated meme (expand/collapse)
If you use Claude Code, Codex, Cursor, or any other coding agent every day, you probably know this pain already: the answer is technically correct, but the response is bloated, repetitive, and padded with tone that adds very little.
caveman is built to attack exactly that problem.
Created by Julius Brussee, the project has a very simple core idea: keep the technical substance, remove the filler, politeness padding, and unnecessary prose. It does not change the model itself. Instead, it adds a response-style layer that can be installed, triggered, switched between levels, and in some environments even auto-enabled.
1. What is Caveman?
According to the README, caveman ships as:
- a skill / plugin for Claude Code
- a plugin for Codex
- an installable skill for Gemini CLI, Cursor, Windsurf, Cline, Copilot, and other agents
Its goal is not to make the assistant say less for the sake of saying less. Its goal is to make the assistant express the same technical judgment in a denser form.
That distinction matters. caveman is not really about personality. It is about output efficiency.
Most prompt-engineering projects chase better reasoning, more stable formatting, or broader capability. caveman goes after a different axis: response density, readability, and token cost.
2. Why does this matter?
In terminal-based agent workflows, verbosity has at least three real costs:
- reading cost: you still have to scan a long reply to find the useful part
- latency cost: more output tokens usually means slower responses
- money cost: when pricing is token-based, fluff is not free
That is why caveman is more than a joke project with a funny tone. It turns “say less” into an operational optimization.
The README makes this point well. The same fix that would normally be explained with a full paragraph can be compressed into a few high-density phrases while keeping the diagnosis and next step intact.
For real development work, that makes sense. Often you do not want an essay. You want:
- What is broken?
- Why is it happening?
- What should I change next?
caveman is clearly designed around that use case.
3. How does it compress responses?
The README defines multiple intensity levels:
- Lite: keep grammar, remove filler and hedging
- Full: default mode, allow fragments, drop more connective tissue
- Ultra: push toward telegram-style compression
- Wenyan modes: compress even further using classical Chinese style
This is one of the more interesting design choices in the project. caveman is not just a single prompt asking for short answers. It turns compression into a structured interface with modes, triggers, and agent-specific integration points.
That means it is better understood as a productized response layer, not a clever one-off trick.
Animated meme (expand/collapse)
4. It is not only about “speaking shorter”
The README also describes a few companion skills:
- caveman-commit: terse commit messages
- caveman-review: dense one-line PR feedback
- caveman-help: quick reference for commands and modes
- caveman-compress: compression for files like
CLAUDE.mdthat get loaded every session
The most interesting one, in my view, is caveman-compress.
The core talking style reduces output tokens. caveman-compress goes after input tokens by rewriting always-loaded memory files into a compressed version while keeping a human-readable backup. For anyone working with large session context files, that is a genuinely practical idea.
So the project is not merely playing with tone. It is treating token budget as a real engineering constraint.
5. What do the README numbers actually mean?
The README highlights two headline numbers:
- about 65% average output-token savings across benchmarked tasks
- about 46% average input-token savings for compressed memory files
It also makes an important clarification: caveman changes output, not internal reasoning tokens. In other words, it is not making the model think less. It is making the model talk less.
That distinction is critical. When people hear “fewer tokens,” they often assume reduced reasoning quality. But the framing in the README is much narrower and more credible: this is an output-format optimization layer, not a capability downgrade.
The README also cites a 2026 paper arguing that brevity constraints can improve accuracy on some benchmarks. Even if you do not treat that as universal law, it still points at an important idea: verbosity is not the same thing as intelligence.
6. Where does Caveman fit best?
I think this project is especially well suited to:
- day-to-day terminal debugging
- quick code review passes
- repeated ask / patch / verify agent loops
- experienced users who already know the local context and do not need tutorial-style explanations
These workflows all benefit from dense answers instead of padded ones.
That said, there are also obvious places where maximum compression is not the right default:
- security warnings or irreversible actions
- onboarding and beginner-facing teaching
- documents meant for long-term team reference
The README reflects that boundary too. Some situations still need clarity over terseness. So caveman should not be read as a replacement for all writing styles. It is a better default for high-frequency technical interaction.
7. Why is the installation section so detailed?
One surprisingly strong part of the README is how much time it spends explaining that “installing the skill” and “having it auto-activate in every session” are different things.
For example:
- Claude Code relies on plugin and hook behavior
- Codex relies on plugin plus repo-level hooks
- several other agents can install the skill but will not automatically enable it as always-on
That level of detail might look mundane, but it reflects a real problem in today’s agent ecosystem: the hard part is often not the feature itself, but how reliably it enters the user’s default workflow.
That is why this README is worth reading even beyond the project’s meme value. It documents installation, activation, mode switching, and always-on behavior as separate operational concerns. That is a sign of real product thinking.
8. Final take
At first glance, caveman looks like a joke project: make your AI assistant talk like a caveman, save tokens, get a laugh.
But if you read the README closely, it is really addressing three practical issues:
- how to reduce friction in agent conversations
- how to make response style a controllable layer
- how to treat token cost as an engineering resource
That is why I think it is worth attention. It reminds us that AI tooling is not only about bigger models, longer context windows, or better benchmark scores. Sometimes the day-to-day experience is shaped by a much smaller question:
Can the model stop talking so much and still stay useful?
caveman argues that the answer is yes, and it packages that answer as something you can actually install and use.