caveman

Overview of caveman skill

What caveman does

caveman is an ultra-compressed response style for AI assistants. It cuts filler, pleasantries, articles, weak hedging, and verbose phrasing while preserving technical accuracy, code, quoted errors, and named concepts. Best fit: users who want dense engineering answers, lower token usage, faster scanning, or persistent “brief mode” across a conversation.

The real job: make assistant output smaller without turning it vague. The upstream skill targets roughly 75% token reduction by changing response shape, not by omitting substance.

Best-fit users and workflows

Use caveman when you already know the domain and want direct answers: code review notes, implementation options, debug hypotheses, CLI reminders, architecture tradeoff summaries, or compact status updates. It is especially useful for long-running Claude sessions where normal assistant style drifts back into polite, over-explained prose.

This caveman skill is also useful for Rewriting: paste verbose text and ask for caveman compression while keeping commands, API names, error messages, and code blocks unchanged.

What makes this caveman skill different

Beyond the core SKILL.md, this repo includes practical validation tooling:

• scripts/caveman_compressor.py applies rule-based compression without LLM calls.
• scripts/caveman_lint.py checks for banned filler, hedging, pleasantries, and verbose phrases.
• scripts/token_savings_estimator.py estimates token and cost savings.
• references/when_caveman_backfires.md documents cases where compression should pause.

That support makes the caveman skill more installable than a simple “be concise” prompt because it defines persistence, exception handling, and measurable output checks.

How to Use caveman skill

caveman install and files to read first

Install with:

npx skills add alirezarezvani/claude-skills --skill caveman

Then inspect the skill folder:

engineering/caveman/skills/caveman

Read in this order:

1. SKILL.md — activation phrases, persistence rule, compression style.
2. references/compression_principles.md — what to cut vs what must stay.
3. references/when_caveman_backfires.md — safety and clarity exceptions.
4. references/companion_tooling.md — script usage and validation workflow.
5. scripts/caveman_lint.py — exact banned vocabulary categories.

This order helps you understand both the behavior and the boundaries before relying on it in production conversations.

How to invoke caveman in practice

Trigger it naturally with phrases like:

• “Use caveman.”
• “Caveman mode.”
• “Be brief, less tokens.”
• “Rewrite this in caveman style.”
• /caveman

The important behavior: once triggered, caveman persists across responses until you say “stop caveman” or “normal mode.” That makes it good for a whole debugging session, but risky if you forget it is active before asking for nuanced instructions.

Strong prompt example:

Use caveman. Review this migration plan. Keep SQL, table names, and rollback commands exact. Compress commentary. If any step is destructive, drop caveman for that warning only.

Why better: it tells the skill what to preserve and acknowledges the auto-clarity exception.

Inputs that improve caveman output

Give caveman clear preservation rules. It compresses language, not requirements. Useful inputs include:

• Target format: bullets, diff notes, checklist, commit message, incident summary.
• Must-preserve items: code blocks, stack traces, API names, legal text, quoted errors.
• Audience: senior engineer, PM, on-call responder, beginner.
• Risk level: safe summary vs irreversible action.

Weak prompt:

Make this shorter.

Better prompt:

Caveman for Rewriting. Compress this support reply to half length. Preserve exact error text, URLs, CLI commands, and refund policy wording. Remove pleasantries and hedging.

Using the companion scripts

The scripts are stdlib-only Python and can run directly from the skill directory.

Compress text:

python scripts/caveman_compressor.py --file input.txt

Lint a response:

python scripts/caveman_lint.py --file response.txt --output json

Estimate savings:

python scripts/token_savings_estimator.py --file input.txt --price-per-mtok 3.00

These tools are useful when you want repeatable compression outside chat, or when you want to verify that an AI response actually followed caveman rules instead of merely being “short.”

caveman skill FAQ

Is caveman only a funny writing style?

No. The “smart caveman” voice is a mechanism for compression: fragments, dropped articles, short synonyms, arrows for causality, and fewer social tokens. The skill is not meant to make technical content primitive. Exact technical terms stay.

When should I not use caveman?

Avoid or temporarily pause caveman for security warnings, irreversible confirmations, high-stakes legal/medical content, or multi-step sequences where terse fragments could cause misread order. The repo’s own backfire reference calls out destructive operations and clarification requests as exception zones.

Good pattern:

Use caveman, except write full warnings for destructive commands.

How is caveman better than “be concise”?

“Be concise” is underspecified and often degrades after a few turns. The caveman skill defines persistent activation, concrete deletion rules, abbreviation patterns, code preservation, and exception cases. The included linter also gives you a way to test compliance rather than trusting the model’s self-assessment.

Is caveman beginner-friendly?

It can be, but only if the beginner asks for clarity exceptions. Pure caveman can remove explanatory connective tissue that beginners need. For learning, use:

Use caveman for summary bullets, but explain new concepts normally first.

That keeps token savings without turning unfamiliar material into cryptic fragments.

How to Improve caveman skill

Make caveman preserve what matters

Best results come from naming what must not be compressed. Tell the assistant to keep these exact:

• Code blocks and inline code
• Error messages
• Security warnings
• Ordered procedures
• API, package, class, table, and field names
• Legal, pricing, or policy wording

Compression should remove fluff around substance, not mutate substance itself.

Common failure modes to watch

Watch for four problems:

1. Over-compression: answer becomes ambiguous.
2. Under-compression: assistant still uses pleasantries and filler.
3. Unsafe compression: warnings or destructive steps become too terse.
4. Format damage: code, commands, or quotes get altered.

Use scripts/caveman_lint.py for under-compression. Use human review for ambiguity and safety, because a linter cannot always know when missing context changes meaning.

Iterate after first output

After the first caveman output, refine with targeted instructions instead of asking for a generic retry:

• “More compressed, keep all command flags.”
• “Restore full sentence for warning only.”
• “Use numbered steps; order matters.”
• “Remove hedging unless evidence-backed.”
• “Keep acronyms expanded on first use.”

This keeps caveman usage controlled: compact where safe, explicit where needed.

Extend caveman for team standards

If using caveman in a team, add local rules beside the skill: approved abbreviations, domains where caveman is banned, preferred output formats, and examples of acceptable compression. Run the compressor and token estimator on real team docs before adoption so you know whether savings justify the readability tradeoff.