If you’ve ever automated tasks with LLMs in production, you know exactly where it hurts: responses that are too long for simple tasks.

In many engineering routines, you don’t need three paragraphs of pleasantries to find out if there’s a bug in a function. You need:

• quick diagnosis;
• minimal context;
• recommended action.

That’s the problem that Caveman solves very well.

What Is Caveman?

Caveman is a skill/plugin for AI agents (like Claude Code and Copilot) that forces an extremely direct response style — less fluff, fewer tokens.

The idea is simple:

• cut courtesy phrases;
• reduce unsolicited explanations;
• keep only the information that really matters.

The result is a “telegraphic” mode of communication, but still technical.

Instead of:

“Of course, great question. Let’s analyze this snippet calmly and consider some important points before arriving at the solution…”

You get something like:

“Null validation bug. Line X. Add check before accessing attribute.”

Less pretty. Much more useful in a pipeline.

Why Does a “Persona” Work Better Than Just Asking to “Be Brief”?

An interesting detail of prompt engineering here: asking to “be concise” doesn’t always work consistently.

Models tend to revert to the default behavior of “helping with full context”. A persona with clear rules (in this case, the caveman style) creates a stronger behavioral anchor.

In practice:

• vague instruction: behavior fluctuates;
• defined persona: more predictable behavior.

For those running repetitive flows, predictability is gold.

How to Install

There are two different options depending on the environment.

Claude Code (plugin)

1
2

claude plugin marketplace add JuliusBrussee/caveman
claude plugin install caveman@caveman

Installation via skills (multi-agent)

1

npx skills add JuliusBrussee/caveman

If you want to install the skill for a specific agent (instead of installing in the default mode), use the -a flag.

Examples:

1
2
3
4
5

# Install for Cursor
npx skills add JuliusBrussee/caveman -a cursor

# Install for Copilot/Codex (when supported in your setup)
npx skills add JuliusBrussee/caveman -a codex

Practical rule: if you work with more than one agent on the same machine, using -a avoids confusion and makes it explicit where the skill was activated.

How to Use Day-to-Day

Caveman brings intensity levels like lite, full, and ultra.

Conceptually:

• lite: reduces fluff, keeps more natural grammar;
• full: standard caveman mode;
• ultra: maximum response compression.

In the daily workflow, this is excellent for switching between:

• productivity mode (review, triage, debugging);
• explanation mode (when you really want detail).

Before / After

Same fix. 75% fewer words.

Where It Shines

The gain is greatest in structured technical tasks, for example:

• function summarization;
• error explanation;
• code review comments;
• log triage;
• fix steps in CI/CD.

In these scenarios, the Caveman ecosystem itself reports significant token reductions in benchmarks and practical examples.

Fewer output tokens generally means:

• lower perceived latency;
• lower cost per call;
• better scannability for humans.

Comparative Benchmarks

Summary: savings range between 22% and 87%, depending on prompt type.

Where You Should Not Use It

Not everything is a hammer.

Avoid Caveman when communication, nuance, and empathy are a core part of the delivery:

• end-user content;
• didactic documentation;
• sensitive topics (legal, health, compliance);
• explanations for beginners on the topic.

In these cases, compressing too much can remove important context.

Example of Hybrid Policy (Recommended)

A mature strategy is to activate compression only for task types that truly benefit from it.

1
2
3
4
5
6

def choose_mode(task_type: str) -> str:
    if task_type in {"review", "summary", "debug", "triage"}:
        return "caveman_ultra"
    if task_type in {"docs", "tutorial", "customer_content"}:
        return "normal_verbose"
    return "normal"

This pattern avoids two extremes:

• wasting tokens on mechanical tasks;
• impoverishing communication on tasks that require context.

An Underrated Feature: Context Compression

In addition to short responses, the project also explores compression of context files (such as instructions and session memory), preserving sensitive technical elements (code, paths, commands) while compressing explanatory text.

This is especially useful when your agent reads fixed files in every session.

Fewer recurring context tokens = more room for the actual task.

Comparative table for caveman-compress (input/context)

Here the focus is not just on output: it’s also about reducing the “reading cost” of context loaded in every session.

Summary

Caveman is a simple and practical way to make AI responses shorter without losing the technical core. In repetitive and structured tasks, the project’s own data shows significant token reductions, with direct impact on read speed, latency, and cost.

The main lesson is objective: default model behavior is not necessarily the best behavior for production. By adjusting the response style with a specific skill, you bring the agent closer to what really matters in day-to-day engineering: operational efficiency, predictability, and quick decision-making.