Caveman, the token-compression skill for AI coding agents, does not ship with a single output style. It offers several intensity levels — most commonly lite, full, and ultra, plus a classical-Chinese wenyan variant — that trade readability for fewer output tokens, and the difference between a smooth and a frustrating experience usually comes down to which level is active for which kind of work. Documentation and community guides consistently identify mode mismatch as the leading cause of mixed results: developers who run ultra on every task find the output hard to parse, while those who never leave lite leave most of the savings unused. This article is a decision guide for developers already running Caveman in agents such as Claude Code, Cursor, or Codex. It maps each compression level to concrete agentic tasks — debugging, code review, architecture discussion, quick fixes, and agent-to-agent traffic — using the skill's documented compression rules as the reference for what each mode actually removes.
Caveman does not ship with a single output style. It exposes several intensity levels — at minimum lite, full, ultra, and a Classical Chinese wenyan variant — but none of them is a "best" setting on its own. The leading cause of mixed results is running one level for every kind of work: ultra on a code review reads like a cryptogram, while staying on lite across a long refactor leaves most of the savings on the table. The rest of this article is a decision framework built around that mismatch.
Inside Claude Code, Cursor, or Codex, a bare /caveman invocation defaults to full. Explicit switches include /caveman lite, /caveman full (equivalent to the default), /caveman ultra, and /caveman wenyan; /caveman off returns the agent to normal prose for the rest of the session (aifordevelopers.substack.com; thepromptshelf.dev). The chosen level sticks until another slash command or a "normal mode" sentence changes it, and mid-session switching is explicitly supported. A project default can also be pinned in AGENTS.md or CLAUDE.md per the 2026 guide on thepromptshelf.dev.
The level matrix is version-sensitive. Older write-ups list four levels (lite, full, ultra, wenyan), while the GitHub README and at least one installation guide describe six, adding wenyan-lite, wenyan-full, and wenyan-ultra combinations — indicating the surface expanded across releases. Treat the installed skill's own SKILL.md as the source of truth rather than any single blog post.
The community digest states the pattern directly: "Matching the mode to the task is where most people go wrong. They crank it to ultra on day one, find the responses hard to parse, and abandon it." The same piece frames the working target as "compression you don't have to fight" (aifordevelopers.substack.com). Other hands-on accounts reach the same conclusion from a different angle: keep lite or full prose when the code is unfamiliar, and reserve ultra for mechanical work where a wrong answer is visible at a glance (mayhemcode.com).
Each task in the sections that follow is evaluated along these two axes:
lite-style grammar; agent-to-agent traffic tolerates and usually prefers ultra.lite (or full prose via normal mode); well-understood refactors and mechanical edits tolerate and benefit from full or ultra.The remainder of the cheat sheet applies this framework to debugging, code review, architecture discussion, quick fixes, and agent-to-agent traffic.
The Caveman skill documents a single compression contract that all intensity settings follow (mcpservers.org). The "Always Drop" rules strip articles (a, an, the), filler words (just, really, basically, simply, actually), pleasantries ("happy to help", "great question", "of course"), and hedging phrases ("you might want to", "perhaps consider", "it could be"). The "Always Keep" rules preserve, unmodified, code blocks; function, class, variable, file, and command names; error messages and stack traces; CLI flags and configuration values; and URLs and file paths. The canonical sentence shape is [thing] [action] [reason]. [next step].
Because this contract is identical across lite, full, ultra, and the wenyan variant, the technical content of a reply is unaffected by which level is active. Multiple secondary sources confirm the byte-for-byte guarantee for code, commands, error strings, and URLs (caveman.so, pasqualepillitteri.it, ysskrishna.space). What changes between levels is purely how aggressively the surrounding prose is rewritten.
lite drops filler words and hedging only; articles remain and full sentences survive. Reported token reduction is roughly 30 percent (8labs.id, skillsllm.com).full (the default) additionally drops articles, permits sentence fragments, and substitutes short synonyms. Reported reduction is roughly 65 percent.ultra goes telegraphic — one-word answers when sufficient, arrows (X → Y) for causality, and prose-word abbreviations such as DB, auth, config, req, res. Code symbols, function names, API names, and error strings are never abbreviated in any mode (ysskrishna.space). Reported reduction is 75 to 80 percent.wenyan is the Classical Chinese variant, generally described as the most aggressive human-targeted mode at roughly 80 to 90 percent character reduction.Treat the published percentages as vendor estimates rather than guarantees: independent measurements report savings ranging from about 22 percent to 87 percent depending on task type (qwe.edu.pl), so mode choice is best understood as a readability dial, not a savings dial. Because the never-touch list is invariant across modes, picking a level is a readability decision rather than a correctness decision — but the guarantee is prompt-enforced, and real-world adherence varies by model and by agent runtime.
When you are working in an unfamiliar part of a codebase, the documented guidance is consistent: keep compression on, but drop to lite. The grammar stays readable, filler is trimmed, and the reasoning the agent shows between code blocks is still long enough to catch what you might miss in terser output. Treat lite as the floor for any debug session where you are not already inside the problem domain. The aifordevelopers guide puts it plainly: "Use lite when you're debugging something unfamiliar or working in a part of a codebase you don't know well."
The mayhemcode.com field guide supplies the matching rule of thumb: keep Caveman on for well-understood tasks such as "add validation to this form" or "refactor this function," but turn it off when debugging something weird such as a test failing in a non-obvious way. The author's reasoning is that you actually want the agent to walk through its chain of reasoning step by step, and the longer answer often catches something a fragmented one would have skipped. In practice that means issuing /caveman off (or simply saying "normal mode") whenever you cannot yet articulate the failure mode.
One source, ysskrishna.space, frames ultra as useful "when you are deep in debugging sessions and already mentally operating in shorthand." That sounds at odds with the mayhemcode rule, but the two are reconcilable: the deciding variable is your familiarity with the system, not the task label. Debugging inside a stack you have lived in for weeks lets you read telegraphic output and still see the bug; debugging a stranger's module on a Friday afternoon does not. Pick the level that matches what you already know.
Two documented behaviors mean you do not have to micromanage this. First, Caveman's auto-clarity feature pauses compression when you appear confused or repeat a question, restores fuller explanations until you are back on track, and then resumes the selected level automatically. Second, quoted tool output — test failures, stack traces, CI logs — is quoted verbatim regardless of mode, so the evidence trail that debugging depends on survives even at ultra. With those as a safety net, the practical rule is simple: lite as the debugging floor, /caveman off for genuinely lost sessions, and ultra reserved for the rare debug session where you already speak the codebase's dialect fluently.
The fastest way to pick a level for review work is to ask one question: who, or what, is going to read the output? The answer splits cleanly into two regimes, and each has a documented best level.
Established guidance from skillsllm.com recommends lite for code reviews and pull request comments where readability still matters. Lite trims redundant phrasing while keeping natural sentence structure — roughly 30 percent token reduction — which is enough to save cost without forcing a reviewer to re-parse telegraphic output to confirm a nuance. This is the level to pick during interactive single-reviewer sessions, pair review, or any case where a human needs to weigh tone, intent, or ambiguous intent behind a change.
The dedicated sub-skill for this case is caveman-review, documented in the caveman-tutorial and on explainx.ai. It generates highly concise one-line PR comments structured around location, problem, and fix. Note its scope: it only outputs review comments ready to paste into the PR. It does not write the fix, approve or request changes, or run linters.
When the consumer is another tool rather than a human — automated review across hundreds of PRs, CI/CD gating steps, or log-analysis and error triage — full (~65 percent reduction) or ultra (75–80 percent reduction) is the right call. Conversational warmth is pure token waste when a program reads the output, and the extra compression compounds quickly across batch jobs.
A useful boundary: PR bodies, commits, and release notes should remain in normal prose. The compressed surface is the comment layer, not the surrounding narrative. Compressing a PR description trades away context that reviewers (human or LLM) need before they ever reach the comments.
The review sub-skill ships under different names across distributions — caveman-review in the canonical JuliusBrussee/caveman repo, cavecrew-reviewer in some forks, and as a Claude Code marketplace plugin in others. Installation paths differ accordingly: the canonical form installs via npx skills add https://github.com/JuliusBrussee/caveman --skill caveman-review, while marketplace installs use the host CLI. The behavior (one-line, location/problem/fix comments, no fix-writing) is consistent across variants; the command name is not, so verify against the installed version before wiring it into a workflow.
Quick fixes, mechanical renames, and test-writing sessions share one trait: the developer already has a mental model of a correct response and is essentially validating the agent's output against it. In that flow state, the readability cost of aggressive compression is negligible — a telegraphic reply is parsed in seconds because you already know what to look for. Documentation of the skill consistently recommends stepping up to full or ultra for exactly this class of work, with the framing that mismatched mode is the leading cause of mixed results (aifordevelopers.substack.com). Concretely, full (about 65 percent reduction) is the sensible default for refactors where you skim but still read each diff, while ultra (roughly 75–80 percent reduction) fits a solo late-night terminal run where every saved repetition matters more than a per-call readability tax (8labs.id).
For isolated edits — typo fixes, single-function rewrites, mechanical renames — the cavecrew-builder preset is the documented delegation target. It is a surgical one-to-two-file editor that explicitly refuses three-or-more-file scope and returns a compressed diff receipt instead of a long natural-language summary (aifordevelopers.substack.com). Offloading this work keeps the main thread's context clean and lets a high-volume session run longer without re-pasting the same instructions. The complementary cavecrew-investigator preset is read-only and returns compressed file:line tables for "where is X defined" style questions, again at roughly 60 percent fewer tokens than a vanilla exploration (aifordevelopers.substack.com).
The presets are documented in the JuliusBrussee/caveman README and installer, which wires cavecrew-investigator, cavecrew-builder, and cavecrew-reviewer into hosts that support native subagents (INSTALL.md). Documented trigger phrases include delegate to subagent, use cavecrew, and spawn investigator/builder/reviewer, but availability and the exact phrasing that a given agent recognises vary by distribution — Codex, Cursor, and Claude Code all install through different native paths. Treat preset access as version-sensitive: confirm the host supports native subagents in your distribution before relying on builder-style delegation as part of a quick-fix workflow.
Architecture discussions are not made of facts and artifacts — they are made of the connective tissue between facts. "If we shard by tenant here, we accept eventual consistency on this read path, but we save a cross-region round trip on that write path." That sentence is the design. Auto-clarity boundary six of the Caveman skill states that compression must never make a technical instruction ambiguous, but ambiguity is not the only failure mode at stake in a design conversation. Compression removes connectives and qualifications, and the connective reasoning of a tradeoff discussion is exactly what it removes. The dev.to limitations coverage explicitly warns against compression for "complex technical explanations," "sensitive or nuanced conversations," and any output destined for documentation or human readers — categories that overlap almost completely with architectural reasoning. Full and ultra are documented as targeting mechanical tasks, refactors, and internal pipelines where the reader already shares the model's context (aifordevelopers.substack.com). A tradeoff weighing neither side of that description applies.
Recommendation (extrapolated): For tradeoff-weighing discussions — causality, hedged comparisons, and qualified "but/if/then only" reasoning — cap at
liteat most, or drop to/caveman off(normal mode) for the duration of the discussion. Re-engagefullorultrafor the implementation phase that follows.
Lite preserves natural sentence structure while trimming filler, which leaves causal connectives and qualifications largely intact. The mode table in the aifordevelopers digest explicitly pairs lite with "exploring unfamiliar code, learning something new" — and an architecture discussion with a colleague or an agent is, structurally, the same activity: absorbing an unfamiliar design under guidance.
/plan when availableIf your host tooling is Caveman Code, the documented /plan mode restricts the agent to read, grep, find, and ls while it produces a written plan without editing files. This pairs naturally with the lite-or-off recommendation: a read-only exploration phase that demands hedged reasoning, followed by an /act execution phase where compression pays for itself again.
Re-enable full (the default) or ultra once the discussion has produced a concrete plan and the work becomes mechanical — writing the migration, editing the schema, updating the tests. That is the part the documented mode descriptions were written for, and that is where the savings stop costing you nuance.
Documentation from the Caveman skill consistently identifies a single use case where maximum compression carries no downside: when the consumer of the output is another program rather than a person. Guidance from skillsllm.com puts it bluntly — for agent-to-agent communication, internal pipelines, and batch processing, conversational warmth, politeness, and sentence structure are "pure token waste." In these contexts, telegraphic ultra mode improves both cost and latency without any readability penalty, because no human ever parses the prose.
The concrete payoff shows up in the subagents that ship with the distribution. The cavecrew-investigator preset is a read-only code locator that returns a file:line table; with Caveman compression applied, the main thread consumes roughly 60% fewer tokens than a vanilla Explore pass would produce. The cavecrew-builder preset — scoped to surgical 1–2 file edits such as typos, single-function rewrites, and mechanical renames — returns a compressed diff receipt rather than prose narration. The cavecrew-reviewer runs an adversarial diff review and returns its findings in compressed form.
The benefit goes beyond token savings. Offloading discrete tasks to compressed subagents keeps the main context clean and lets complex sessions run noticeably longer, because every token an investigator or reviewer returns is one less token competing for the main thread's context budget.
Persistence mechanics documented at mcpservers.org matter here. Caveman has no out-of-band state store, daemon, or hook — mode state lives entirely in the conversation transcript, and the latest matching activation or level-switch directive wins. If the transcript is cleared, the conversation ends, or the activation message falls out of context scope, the mode is off by default. The skill file is loaded on demand; once the rules are in context, they keep applying without reloading, but if compaction trims them out, the next directive should reload caveman/SKILL.md.
The practical implication for long multi-agent sessions: a context trim can silently drop you back to default voice mid-session. Re-invoke the chosen level after compaction to keep subagent output consistent.
Trigger phrasing and preset names differ across distributions and have evolved over time. Subagent trigger phrases such as delegate to subagent, use cavecrew, or spawn investigator/builder/reviewer are version-sensitive, as are the preset identifiers themselves. Before relying on a specific invocation in production pipelines, verify the exact phrasing against the distribution's current skill file, since a renamed preset will silently fall through to default behavior rather than failing loudly.
Caveman documents a fixed set of contexts where the skill switches itself off without being told, then resumes the previously selected level once the section ends. According to the skill's own rules, auto-clarity pauses compression for:
delete, drop, force push, rm -rf.In addition, code, commit messages, PR bodies, and release notes are always written in normal prose, regardless of which level is active. Treat auto-clarity as a safety floor, not as something to override per task: when it fires, the cost of skipping a confirmation or a Back up first. prefix is higher than the tokens saved.
Caveman is adaptive rather than a flat discount. As qwe.edu.pl notes, a session where roughly 30% of operations trigger safety prose lands closer to 50–55% actual compression rather than the advertised 65–75% headline figure, and the adaptation is silent — most tutorials do not mention it. Your realized savings therefore depend on your task mix: debugging and destructive operations pull it down, code reviews and function explanations push it up.
The /caveman-stats command reads the session log, reports lifetime tokens saved, shows an estimated USD figure, and on Claude Code writes a real-time statusline counter. A --share flag produces a tweetable summary. The qwe.edu.pl workflow recommends testing your own five most common tasks per mode and applying a decision threshold rather than trusting published percentages.
A practical default: set full in AGENTS.md as the baseline, then switch per task using the cheat sheet earlier in this article. Let auto-clarity handle the dangerous cases instead of trying to override it. Re-run your five-task benchmark after each version update, since mode names and stats output have changed across releases.