Best Claude Skills to Reduce Token Usage (2026): Caveman, RTK and 5 Methods That Work

Most skills add tokens. These ones cut them: Caveman, RTK, caveman-compress and claude-token-optimizer, plus the five methods behind them, with install commands, honest numbers and what each one actually saves.

Most skills add tokens. They add context, instructions and quality checks, and every one of those is billed. So the useful question is not "which skills reduce tokens?" but "which skills remove more tokens than they add?"

My Claude Code bill one month was $87. Not outrageous. But when I broke down where the tokens went, the result was depressing.

About 40% was filler. "Certainly! I'd be happy to help you refactor that function. Let me walk you through the changes step by step..." That preamble costs money and adds nothing. Multiply it by 200 interactions and you're paying for a polite assistant who won't stop explaining things you didn't ask to have explained.

Another 30% was re-prompts. The agent built the wrong thing because the instructions were ambiguous. I described the fix. It rebuilt. Two round trips instead of one, double the tokens for the same output.

The last 30% was actual useful work.

This guide covers the named skills and tools developers actually install to fix that, what each one measurably saves, and the five methods underneath them, so you can pick what fits instead of installing everything.

Do skills actually reduce token usage?

Yes, but only some of them. A skill that compresses output, compresses the files Claude reads, or routes work to a cheaper model reduces the tokens per call. A skill that adds a capability (web search, file reading, tool calling) increases token usage, because it adds its own instructions, tool schemas and tool results to the context.

Even a token-saving skill has a cost. Skills load on demand in Claude Code (each one costs roughly 30-100 tokens at startup for its name and description, per Firecrawl's breakdown), but once a skill is active its full instructions sit in the context. Caveman's own README puts its rules at about 1,160 input tokens, and Skillselion's review says about 1,000-1,500 per turn. It still saves tokens overall, because output tokens cost 5x input tokens on Claude, but the saving is smaller than the headline number.

So the net effect depends on which skills you install. The ones below are built to remove tokens, not add features.

The best Claude skills and tools to reduce token usage (October 2026)

GitHub stars as of 27 October 2026: Caveman about 115,000, RTK about 85,000, claude-token-optimizer about 630. Savings are the projects' own measurements unless stated.

Caveman: the token-saving skill for output

Caveman is the most-starred token-saving skill for Claude Code, with about 115,000 GitHub stars (v4.0.1, released 13 October 2026). It makes the agent answer in a terse, stripped-down voice while leaving code, commands and error text exact. Turn it on with /caveman, go harder with /ultracave, and switch it off with /caveman off or "stop caveman". In Codex the trigger is $caveman.

Install in Claude Code:

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

For Codex, Gemini CLI, OpenCode and the other supported agents, the project's installer covers them in one step:

npx @caveman-ai/cli@latest

Honest numbers: on ten dev questions run on Claude Opus 5.5, output dropped from 6,983 tokens to 4,119 with /caveman and 2,693 with /ultracave. A plain "Answer concisely." instruction got to 4,334 on the same set, and the README itself calls that the real baseline: against it, /caveman cuts 3% more at the median and /ultracave 35% more. So most of the standard mode's saving is available without the skill; /ultracave is where it pulls ahead. The project also reports 33.2% fewer input tokens across 54 full Claude Code sessions (an August 2026 run on an older version), from the extras that compress logs, JSON and test output before the model reads them. JetBrains measured 8.5% fewer output tokens across 86 real coding tasks with no measurable quality loss, and Elastic 63.6% fewer response tokens in eight MCP scenarios, so expect your result to depend heavily on how chatty your agent was to begin with.

The catch: compressed output reads cold. For code and technical work that's fine. For customer-facing content or anything where tone matters, turn it off.

RTK (Rust Token Killer): the token saver for shell output

RTK is a single Rust binary that sits between your agent and the terminal. When the agent runs git status, cargo test or npm install, RTK filters the output down to what matters before it enters the context. The project claims 60-90% smaller output on common dev commands, and it supports 18 AI coding tools, including Claude Code, Codex, Cursor, GitHub Copilot and Gemini CLI.

brew install rtk
rtk init -g            # Claude Code
rtk init -g --codex    # Codex

Two caveats from the project itself. The saving applies to bash output only (the hook fires on Bash tool calls), not your whole bill. And token counts are estimated from bytes, so trust the percentages more than the absolute numbers. Another project called "rtk" exists on crates.io, so check that rtk gain works after installing.

RTK pairs well with Caveman: Caveman shrinks what the agent writes, RTK shrinks what it reads.

caveman-compress and claude-token-optimizer: smaller files at session start

Claude Code loads your CLAUDE.md and memory files at the start of every session, before you type anything. Firecrawl measured 20,000-30,000 tokens loaded before the first prompt on a typical setup. Two tools attack that directly:

• caveman-compress rewrites memory files such as CLAUDE.md into a compressed form (it sends the file to your configured model to do it). The project's check across five files went from 6,198 to 4,138 tokens, a 23-49% cut per file.
• claude-token-optimizer keeps a short CLAUDE.md and a few small reference files loaded, and moves older docs, session notes and finished task lists into files Claude reads only when needed. On the author's RedwoodJS project, startup tokens fell from about 11,000 to about 800. Run npx -y claude-token-optimizer measure to see your own number first.

This is the one saving you get on every single session, so it is usually the best place to start.

Is there a token optimizer skill?

Yes, several projects use the name. The most practical is nadimtuhin's claude-token-optimizer (above), which trims what Claude loads at session start. Others are smaller and work differently: KINGSTAR-OMEGA's claude-token-optimizer is a pair of prompt protocols (one plans in files and asks clarifying questions, one forces JSON-only replies), and valorisa's rescue-tokens skill is a checklist for long conversations, verbose output, the wrong model and too many MCP servers. In practice "token optimization" comes from combining a few tools that each attack one part of the bill: Caveman for output, RTK for shell output, a session-start optimizer for memory files, and MCP pruning for tool schemas.

How to reduce token usage on your AI agent

Before picking skills, understand where your tokens go. A typical agent call has four parts, and each one consumes tokens:

1. System prompt (your agent's instructions): usually 300-800 tokens, sent on every call.
2. Tool and skill schemas: roughly 100-200 tokens per tool, sent on every call.
3. Conversation history: grows with every turn, and is often the biggest cost.
4. The model's response: billed as output tokens, which cost 5x the input rate on Claude.

The fastest ways to cut your bill:

Shorten your system prompt. Every word in it is sent on every call. A 500-word prompt (about 650 tokens) costs roughly $0.0013 per call on Claude Sonnet 5.5, or $0.26 a day at 200 calls. Small on its own, but it scales with every agent and every call. Cut it to 200 words and that line drops by 60%.

Limit conversation history. Most agents don't need the full history on every call. A sliding window of the last 3-5 turns cuts context by 70-80% on long conversations. Trimming an 8,000-token history to 2,000 tokens saves $4.80 a day at 200 calls on Claude Opus 5.5.

Load only the tools you need. Each MCP tool schema adds 100-300 tokens to every call. An agent with 10 MCP tools sends 1,000-3,000 tokens of schemas on every request, even if it never uses most of them. (Method 4 below covers MCP pruning in depth.)

Use cheaper models for simple tasks. Classification, tagging and routing don't need a frontier model. Claude Haiku 5.5 ($0.10/$0.50 per million tokens for prompts up to 100K tokens) costs 97.5% less than Claude Opus 5.5 ($4/$20).

Then use the skills above and the methods below to optimize what's left.

How to reduce token usage in Claude Code (built-in options)

Claude Code has several token controls built in. Use these before installing anything (all from Anthropic's cost guide):

• /context shows what is filling your context window right now. Start here.
• /compact summarizes the conversation so far; /clear starts fresh when you switch tasks. /clear costs nothing, while /compact is itself a large request, so clear between unrelated tasks.
• Keep CLAUDE.md short. Anthropic's guidance is under 200 lines per file; Firecrawl cut one file from 3,847 tokens to 312.
• Read deny rules in permissions.deny keep Claude from reading build folders, lockfiles and generated code. A .claudeignore file has no effect; Anthropic's docs say to move its entries into deny rules.
• Path-scoped rules in .claude/rules/ (with paths: frontmatter) load only when Claude works with matching files.
• MCP Tool Search (on by default in current Claude Code) defers MCP tools and discovers them on demand instead of loading every schema up front.
• Plan mode (press Shift+Tab until the status bar shows plan mode) before large changes cuts wrong-direction work, which is the most expensive kind.

How to reduce token usage in Codex

The same tools work in OpenAI's Codex CLI. RTK installs for Codex with rtk init -g --codex, and Caveman's npx installer covers Codex too. A good AGENTS.md file also saves tokens: in a study of 124 pull requests across 10 repositories, run with and without the file (Lulla et al., arXiv:2601.20404), AGENTS.md cut output tokens by 16.6% and median runtime by 28.6%. Our AGENTS.md best practices guide covers how to write one.

What token reduction actually saves you (in dollars)

Here's what a typical agent costs before and after optimization, at 200 calls a day:

These numbers use Anthropic's API pricing as of October 2026 (Claude Sonnet 5.5 at $2/$10 per million input/output tokens, Claude Opus 5.5 at $4/$20) and don't include prompt caching, which would lower both columns further. Even without model routing, the context and output cuts alone take the Opus-only bill from ~$304 to ~$87 a month. Route the simplest 70% to Claude Haiku 5.5 instead of Sonnet and the after column drops further still. BYOK users on BetterClaw pay the provider directly at these rates, with zero markup.

The 5 methods behind every token-saving skill

Every tool above works through one of five methods. If a skill you're looking at doesn't do one of these, it probably adds tokens rather than removing them.

Method 1: Output compression (the "Caveman" approach)

The most talked-about token optimization is forcing the agent to communicate in terse, direct language: no filler phrases, polite openers, transitional sentences or step-by-step explanations you didn't ask for.

Without compression: "I've successfully completed the refactoring of the authentication module. The changes include updating the token validation logic, restructuring the middleware chain, and adding comprehensive error handling. Here's a detailed walkthrough of each change..." That's 45 tokens of pure wrapping around the actual content.

With compression: "Auth module refactored. Token validation updated. Middleware restructured. Error handling added." Same information. 12 tokens.

The numbers: a typical response runs 300-500 tokens without compression and 80-150 tokens with aggressive compression. Over 30 exchanges in a session, that's 9,000 to 12,000 tokens saved. Towards AI benchmarked the approach at 75% reduction per session; Caveman's own test shows 41% fewer output tokens than no instruction in its standard mode and 61% in /ultracave. Anthropic's guide to building skills gives an illustrative example of the same effect: a task that takes 15 back-and-forth messages and 12,000 tokens without a skill takes 2 clarifying questions and 6,000 tokens with one.

The catch: compressed output reads cold. Keep it toggleable, not permanent.

Method 2: First-pass accuracy (get it right the first time)

This method doesn't look like a token optimization, but it's the biggest one.

A skill that catches bugs before you commit means fewer "fix the bug I just introduced" conversations. A skill that knows your project's testing framework generates tests that pass on the first run. An architecture skill that knows your conventions stops the agent from generating code in the wrong structure, which you then have to ask it to redo.

Every re-prompt costs a full round trip. The agent re-reads the context, processes the correction and generates a new response. One re-prompt on a 30,000-token context costs 30,000+ tokens in re-read plus 500+ in generation. Prevent one re-prompt per session and you save more tokens than any output compression skill.

MindStudio benchmarked five token-cutting skills and found the same result each time: fewer misunderstandings lead to fewer re-prompts and fewer tokens. A structured five-phase approach (plan, then build, then verify) used 14% fewer tokens and cost 9% less than unstructured sessions on the same model.

This is why agent skills that encode your project conventions matter so much. A skill that tells the agent "use functional components, never class components" prevents a wrong-architecture generation that costs 50,000+ tokens to fix.

Method 3: Code scripts over markdown instructions

This one's counterintuitive. Most skills are written as markdown: natural language instructions that the agent reads and follows.

But MindStudio published data showing that executable code scripts reduce tokens by up to 90% compared to markdown instructions for the same task. Markdown instructions are verbose by nature: "When the user asks you to process data, first check if the file exists, then read the contents, then validate the format, then..." That's a paragraph the agent reads and interprets on every invocation. A script does the same thing in 10 lines. The agent doesn't interpret it; it runs it.

Scripts are also more reliable. "Validate the format" means different things on different runs. A script that checks isinstance(data, dict) and 'id' in data does exactly one thing, every time. Caveman's "Blocks" add-on (still a pre-release) is built on this idea: reusable scripts the agent runs instead of rewriting. On a 326-test go test run, raw output was 10,561 tokens, | tail -20 brought it to 397, and the block brought it to 76.

For skills that perform a consistent, repeatable action (data processing, file management, API calls, format conversion), write them as code scripts. Save markdown instructions for skills that need flexible interpretation.

Method 4: MCP server pruning (the invisible token drain)

Each MCP server connected to your agent loads its tool definitions into the context window, on every message and every turn, whether or not you use those tools in this interaction.

MindStudio measured a single MCP server at up to 18,000 tokens per turn in tool definition overhead. Connect three feature-rich servers and you can burn 50,000+ tokens per conversation on tool schemas the agent never calls. Damian Galarza found MCP tool definitions can take 24% or more of the context window before a single message is sent. For some tools, direct API calls instead of MCP avoid the overhead entirely.

The fix is simple but often overlooked: unload MCP servers you're not actively using. If today's task doesn't need GitHub, disconnect it. If you only need Slack this session, don't also load Jira, HubSpot and Google Drive. (For more on where MCP fits versus skills, see our guide on agent Skills vs MCP.)

Anthropic addressed this partially in January 2026 with MCP Tool Search. In current Claude Code it's on by default: MCP tools are deferred and discovered on demand instead of all loading up front (ENABLE_TOOL_SEARCH=auto restores the old "only past 10% of context" behaviour). Not every agent framework does this, though, and Claude Code 2.1.296 (9 October 2026) doubled the default limit on MCP tool descriptions sent up front from 2,048 to 4,096 characters. Longer allowed descriptions mean more tokens per tool anywhere tools load eagerly, so pruning matters more, not less.

On BetterClaw, the agent works as an MCP client and you tick only the tools it needs on each MCP server, which is the same pruning without editing a config file. Skills load the same way: only the ones relevant to the current task use context tokens.

Method 5: Context injection over context re-sending

The most wasteful habit of all is re-sending the same project context in every conversation.

Project structure: 800 tokens. Dependencies: 600. Coding standards: 400. Architecture decisions: 700. API docs: 500. Previous decisions: 400. Total: 3,400 tokens sent at the start of every single conversation. Ten conversations a day is 34,000 tokens on repeated context; a month is over 1,000,000 tokens that carry zero new information.

The solution: store context in a persistent, efficient format and inject it on demand rather than re-sending it raw. This is what prompt caching does at the provider level (on Claude Opus 5.5, cached input costs $0.20 per million tokens against $4 uncached; see our guide to prompt caching for agents). You can also do it at the skill level, which is exactly what caveman-compress and claude-token-optimizer do: instead of loading a 2,000-token README, keep a 200-token summary of the decisions and conventions that matter, and let the agent open the full file only when it needs it.

How do token compression tools cut costs without hurting output quality?

They remove words the model or the reader doesn't need, and leave the parts that carry meaning exact. Caveman keeps code, commands and error messages untouched and only strips the prose around them; RTK filters noise out of command output before the agent reads it. JetBrains measured 8.5% fewer output tokens with no measurable quality loss using Caveman on 86 coding tasks.

Quality drops in two places. Over-compressed summaries of project context can drop a decision the agent needed, so start with light compression and check the output before going further. And terse prose is a bad fit for anything a customer reads. Compress what machines read; leave what people read alone.

The compound effect

These methods don't just add up; they compound. Output compression cuts per-response tokens by 65-75% at its strongest. First-pass accuracy removes 30-50% of round trips. Code scripts cut instruction overhead by up to 90%. MCP pruning recovers 24%+ of the context window. Context injection removes 90%+ of repeated context.

Apply all five and a session that would have used 150,000 tokens might use 25,000-40,000. Same work, same output quality, 75-85% less cost.

A practical starter stack for Claude Code:

1. Run /context and npx -y claude-token-optimizer measure to see your baseline.
2. Trim CLAUDE.md under 200 lines, or run caveman-compress on it.
3. Install RTK and run rtk init -g.
4. Install Caveman and use /caveman for coding sessions, off for writing.
5. Disconnect MCP servers you don't use today.
6. Measure again with npx ccusage@latest after a week.

Gartner projects 40% of enterprise applications will embed AI agents by end of 2026. As adoption scales, the teams that optimize their token costs now are the ones that can afford to run more agents, more often, on harder problems. For the model-selection side of the same problem, see our model routing setup guide and our guide to cutting agent API costs by 80%.

Give BetterClaw a look if you want token optimization handled for you. Context management that prevents bloat by design, skills that load only when needed, 500+ connectors with per-tool MCP selection on paid plans, and 28+ model providers with your own keys at zero markup. Free plan with 1 agent and 100 credits a month, and $49/month on Pro for 5 agents, with a kill switch on every plan. We handle the token costs. You handle the agent logic.

Frequently Asked Questions

What are the best Claude skills to reduce token usage?

Caveman for output (4,119 output tokens instead of 6,983 in standard mode and 2,693 in /ultracave on its own ten-question test), RTK for shell and test output (60-90% smaller on common dev commands), and caveman-compress or claude-token-optimizer for the files Claude loads at session start. Add MCP pruning and you cover the four biggest sources of waste. Most other skills add tokens.

Do skills save tokens?

Only skills built to remove tokens do. Skills that compress output, compress files or route to cheaper models save tokens; skills that add capabilities (search, tools, file access) add tokens. Even a saving skill costs something: Caveman's rules add about 1,000-1,500 input tokens per turn while active, and earn it back by cutting output tokens, which cost 5x as much on Claude.

What is the Caveman skill?

An open-source skill for Claude Code and 30+ other coding agents (JuliusBrussee/caveman, about 115,000 GitHub stars) that makes the agent answer in terse, stripped-down language while keeping code exact. Install it in Claude Code with claude plugin marketplace add JuliusBrussee/caveman and claude plugin install caveman@caveman, then use /caveman, /ultracave or /caveman off.

Is there a token optimizer skill for Claude Code?

Yes. nadimtuhin's claude-token-optimizer trims what Claude Code loads at session start (about 11,000 to about 800 startup tokens on the author's project); run npx -y claude-token-optimizer measure to check yours. Other repos with similar names are smaller prompt protocols and checklists.

What is RTK (Rust Token Killer)?

A single Rust binary (rtk-ai/rtk, about 85,000 GitHub stars) that filters command output before your agent reads it, cutting it by 60-90% on common dev commands. It works with Claude Code, Codex, Cursor, Copilot, Gemini CLI and 13 other tools. Install with brew install rtk, then rtk init -g (add --codex for Codex).

How do I reduce token usage in Claude Code without installing anything?

Check /context, keep CLAUDE.md under 200 lines, add Read deny rules for build folders and lockfiles, use /clear between tasks and /compact within long ones, keep MCP Tool Search on, disconnect MCP servers you aren't using, and use plan mode before large changes.

How much do token-saving skills actually reduce costs?

Individual methods produce measurable results: output compression saves 65-75% per response at its strongest (Towards AI), code scripts save up to 90% versus markdown (MindStudio), and MCP pruning can recover 24%+ of the context window (Damian Galarza). Combined, they compound to 75-85% total session reduction. In our worked example, an Opus-only agent at 200 calls a day drops from about $304 to about $56 a month.

Can token-saving skills degrade output quality?

Output compression reduces explanation, which is fine for code but worse for written content, so keep it toggleable. First-pass accuracy and code scripts improve quality while reducing tokens. MCP pruning only affects tokens, as long as you keep the servers you need. Context compression can hurt quality if summaries drop key decisions; start light and check the output before going further.

Do token-saving skills work on BetterClaw?

Yes. With your own model keys (BYOK), every token you save comes straight off your provider bill, with zero markup. Context management is built in: skills load only when a task needs them, and on paid plans you can tick exactly which tools each MCP server exposes to the agent. The Free plan (1 agent, 100 credits a month) is enough to try it.