AI Skill

Fail

Audit score 45

caveman-compress

juliusbrussee/caveman

Compress memory files into caveman-speak to save input tokens while preserving code and structure.

What is caveman-compress?

Reduces token usage in natural language files (CLAUDE.md, todos, preferences) by removing filler words and redundant phrasing while preserving all code, URLs, technical terms, and markdown structure. Creates a human-readable backup before overwriting the original.

Removes articles, filler words, pleasantries, and hedging language
Preserves code blocks, inline code, URLs, file paths, and commands exactly as-is
Maintains markdown structure, headings, lists, and tables
Compresses only prose sections in mixed content files
Validates output and retries up to 2 times on errors
Backs up original file as FILE.original.md before compression

How to install caveman-compress

npx skills add https://github.com/juliusbrussee/caveman --skill caveman-compress

Prerequisites

Python 3 installed
Access to the caveman-compress skill package

Claude Code

Cursor

Windsurf

Cline

How to use caveman-compress

1.Run `/caveman-compress <filepath>` or ask to compress a memory file
2.The skill detects file type and calls Claude to compress
3.Compressed version overwrites the original file
4.Human-readable backup is automatically saved as `<filename>.original.md`
5.If errors occur, the skill attempts targeted fixes up to 2 times
6.Check the compressed file and restore from .original.md if needed

Use cases

Good for

Reduce token consumption when loading large CLAUDE.md context files
Compress project documentation and preference files for faster agent processing
Shrink todo lists and notes while keeping all actionable information
Optimize memory files before sharing with token-limited AI systems
Maintain readable backups of original files for reference

Who it's for

AI agent users managing large context files
Developers optimizing token usage in Claude Code or Cursor
Teams maintaining shared memory and preference documentation
Anyone working with token-limited AI systems

caveman-compress FAQ

What file types can be compressed?

Only natural language files: .md, .txt, .typ, .typst, .tex, and extensionless files. Code files (.py, .js, .json, .yaml, etc.) are never modified.

Will my code blocks be changed?

No. Code blocks (fenced ``` and indented), inline code, URLs, file paths, and commands are preserved exactly as-is. Only prose text outside code is compressed.

Can I recover the original file?

Yes. The original is automatically backed up as `<filename>.original.md` before compression. You can restore it anytime.

What happens if compression fails?

The skill retries up to 2 times with targeted fixes. If still failing, it reports the error and leaves the original file untouched.

How much token savings should I expect?

Typical compression removes 30-50% of tokens by eliminating filler words, articles, and redundant phrasing while keeping all technical substance.

Full instructions (SKILL.md)

Source of truth, from juliusbrussee/caveman.

name: caveman-compress description: > Compress natural language memory files (CLAUDE.md, todos, preferences) into caveman format to save input tokens. Preserves all technical substance, code, URLs, and structure. Compressed version overwrites the original file. Human-readable backup saved as FILE.original.md. Trigger: /caveman-compress FILEPATH or "compress memory file"

Caveman Compress

Purpose

Compress natural language files (CLAUDE.md, todos, preferences) into caveman-speak to reduce input tokens. Compressed version overwrites original. Human-readable backup saved as <filename>.original.md.

Trigger

/caveman-compress <filepath> or when user asks to compress a memory file.

Process

The compression scripts live in scripts/ (adjacent to this SKILL.md). If the path is not immediately available, search for scripts/__main__.py next to this SKILL.md.
From the directory containing this SKILL.md, run:

python3 -m scripts <absolute_filepath>

The CLI will:

detect file type (no tokens)
call Claude to compress
validate output (no tokens)
if errors: cherry-pick fix with Claude (targeted fixes only, no recompression)
retry up to 2 times
if still failing after 2 retries: report error to user, leave original file untouched

Return result to user

Compression Rules

Remove

Articles: a, an, the
Filler: just, really, basically, actually, simply, essentially, generally
Pleasantries: "sure", "certainly", "of course", "happy to", "I'd recommend"
Hedging: "it might be worth", "you could consider", "it would be good to"
Redundant phrasing: "in order to" → "to", "make sure to" → "ensure", "the reason is because" → "because"
Connective fluff: "however", "furthermore", "additionally", "in addition"

Preserve EXACTLY (never modify)

Code blocks (fenced ``` and indented)
Inline code (backtick content)
URLs and links (full URLs, markdown links)
File paths (/src/components/..., ./config.yaml)
Commands (npm install, git commit, docker build)
Technical terms (library names, API names, protocols, algorithms)
Proper nouns (project names, people, companies)
Dates, version numbers, numeric values
Environment variables ($HOME, NODE_ENV)

Preserve Structure

All markdown headings (keep exact heading text, compress body below)
Bullet point hierarchy (keep nesting level)
Numbered lists (keep numbering)
Tables (compress cell text, keep structure)
Frontmatter/YAML headers in markdown files

Compress

Use short synonyms: "big" not "extensive", "fix" not "implement a solution for", "use" not "utilize"
Fragments OK: "Run tests before commit" not "You should always run tests before committing"
Drop "you should", "make sure to", "remember to" — just state the action
Merge redundant bullets that say the same thing differently
Keep one example where multiple examples show the same pattern

CRITICAL RULE: Anything inside ... must be copied EXACTLY. Do not:

remove comments
remove spacing
reorder lines
shorten commands
simplify anything

Inline code (...) must be preserved EXACTLY. Do not modify anything inside backticks.

If file contains code blocks:

Treat code blocks as read-only regions
Only compress text outside them
Do not merge sections around code

Pattern

Original:

You should always make sure to run the test suite before pushing any changes to the main branch. This is important because it helps catch bugs early and prevents broken builds from being deployed to production.

Compressed:

Run tests before push to main. Catch bugs early, prevent broken prod deploys.

Original:

The application uses a microservices architecture with the following components. The API gateway handles all incoming requests and routes them to the appropriate service. The authentication service is responsible for managing user sessions and JWT tokens.

Compressed:

Microservices architecture. API gateway route all requests to services. Auth service manage user sessions + JWT tokens.

Boundaries

ONLY compress natural language files (.md, .txt, .typ, .typst, .tex, extensionless)
NEVER modify: .py, .js, .ts, .json, .yaml, .yml, .toml, .env, .lock, .css, .html, .xml, .sql, .sh
If file has mixed content (prose + code), compress ONLY the prose sections
If unsure whether something is code or prose, leave it unchanged
Original file is backed up as FILE.original.md before overwriting
Never compress FILE.original.md (skip it)