caveman: The Repo That Turns LLM Chatter Into a Compression System
A terse-speech skill for coding agents, a file-compression pipeline, and safety rails that make brevity useful instead of reckless.
Caveman only affects output tokens — thinking/reasoning tokens are untouched. Caveman no make brain smaller. Caveman make mouth smaller.
- caveman treats verbosity as a systems problem, not a tone preference.
- The repo compresses both output and input, then adds validation so essential technical details survive the rewrite.
- Its strongest idea is not caveman-speak itself, but turning concision into a repeatable toolchain across agents and workflows.
- The project replaces vague advice like "be brief" with enforced behavior, backups, hooks, and evaluation.
Why fewer words is the point
Most AI coding tools are rewarded for being helpful, and helpful often means long. `caveman` pushes in the other direction. It treats the verbosity tax as something you can engineer away, then packages that restraint into a skill you can install.
The repo turns style into a system
The surprise is that `caveman` is not just a prompt. It is a stack. The repo spans skills, compression tooling, hooks, plugins, and evaluation, which means terse speech is not a one-off trick. It is a behavior layer that can follow the user across tools.
skills/
caveman/
caveman-commit/
caveman-review/
caveman-compress/
scripts/
compress.py
validate.py
hooks/
caveman-activate.js
evals/
benchmarks/The prompting engine is the brain
Inside `skills/caveman/SKILL.md`, the repo defines a ladder of intensity: lite, full, ultra, and wenyan. That matters because it gives the user a knob, not a slogan. The model is taught to strip filler, compress sentence shape, and still back off when precision matters.
Based on the viral observation that caveman-speak dramatically reduces LLM token usage without losing technical substance. So we made it a one-line install.
That safety rail is the story. `caveman` is opinionated, but it is not reckless. The repo explicitly makes room for clarity when the task is security-sensitive or irreversible. Brevity is the default. Precision still wins.
Compression is where the rigor shows up
The strongest technical move lives in `caveman-compress`. The script reads a markdown file, rewrites the prose, validates the result, and keeps a `.original.md` backup. That backup is not decoration. It is the admission that compression can go wrong, and that recoverability matters.
| Approach | What it optimizes | What it sacrifices | What caveman adds |
|---|---|---|---|
| Manual prompt brevity | Shorter replies by habit | Consistency and enforcement | A repeatable skill with modes and defaults |
| Generic AI coding assistant behavior | Helpfulness and context | Token density | Terse output as the operating norm |
| caveman | Output and input compression | Some linguistic comfort | Validation, backups, hooks, and task-specific modes |
The repo also answers the obvious objection: what if compression deletes the thing you needed? Its validator exists to catch exactly that. Code blocks, URLs, headings, and paths are treated as protected atoms. The prose can shrink. Those elements cannot.
Hooks make the behavior persistent
`hooks/caveman-activate.js` removes friction. It writes the active flag, loads the skill at runtime, and makes the mode feel native inside the agent session. That matters because good workflow tools disappear into habit. The user should not need to remember the policy every time.
Wenyan is the weirdest smart idea here
The most surprising mode is `wenyan`. Classical Chinese is a dense target language, which makes it a clever stress test for the project's premise: reduce tokens per idea without reducing technical substance. It is funny on the surface, but it also reveals how seriously the repo thinks about linguistic compression.
🪨 why use many token when few token do trick — Claude Code skill that cuts 65% of tokens by talking like caveman
What it replaces, and what it does not
`caveman` is not a replacement for a full AI editor, a code assistant, or careful human judgment. Cursor and Copilot attack broader problems. `caveman` attacks a narrower one: how much the assistant says, how cheaply it says it, and how consistently that behavior can be enforced.
That narrowness is the point. Generic advice like "be brief" depends on discipline. `caveman` turns discipline into plumbing.
The real takeaway
The larger lesson is not that LLMs should always speak like a caveman. It is that communication style is becoming a programmable layer in agent workflows. Once that layer can be installed, validated, and measured, verbosity stops being a personality trait and becomes an optimization target.
