"I'm trying to reduce token usage, but I haven't found any good Skills that help." That Reddit post has 340 upvotes because most skills ADD tokens. Here are the five patterns that actually cut them.
My Claude Code bill last month was $87. Not outrageous. But when I broke down where the tokens went, the math 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. It 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.
Here's the uncomfortable truth about agent skills and token usage: most skills increase your token consumption. They add context. They add instructions. They add quality checks. All of which cost tokens. The question isn't "which skills reduce tokens?" It's "which skill patterns change the token math in your favor?"
Five patterns. Tested. Measured. Here's what actually works.
Pattern 1: Output compression (the "Caveman" approach)
The most talked-about token optimization right now is a skill that forces the agent to communicate in terse, direct language. The community calls it the "Caveman" skill. It strips every response of filler phrases, polite openers, transitional sentences, and 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. With aggressive compression, the same response runs 80-150 tokens. Over 30 exchanges in a session, that's 9,000 to 12,000 tokens saved. Towards AI benchmarked the pattern at 75% reduction per session. Anthropic's own data shows a task that took 15 back-and-forth messages and 12,000 tokens without a skill took 2 questions and 6,000 tokens with one.
The catch: compressed output reads cold. For code generation and technical work, that's fine. For customer-facing content or anything where tone matters, you want the full output. The skill should be toggleable, not permanent.
Pattern 2: First-pass accuracy (get it right the first time)
Here's the pattern that nobody talks about because it 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. Each bug-fix round trip consumes tokens. A skill that knows your project's testing framework generates tests that pass on the first run instead of requiring "the test fails, fix it" follow-ups. An architecture skill that knows your conventions prevents the agent from generating code in the wrong pattern, which you then have to ask it to redo.
The math: 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 pattern consistent: fewer misunderstandings lead to fewer re-prompts lead to fewer tokens. Explicit planning leads to less context re-loading. Verification during the session leads to fewer bugs caught afterward and fewer follow-up sessions.
The highest-ROI token reduction isn't making responses shorter. It's making responses correct the first time. One prevented re-prompt saves more tokens than 20 compressed responses.
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.
Pattern 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. Makes sense. The agent understands language.
But MindStudio published data showing that executable code scripts reduce tokens by up to 90% compared to markdown instructions for the same task. Why?
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 of instructions the agent reads and interprets on every invocation.
A code script does the same thing in 10 lines of actual code. The agent doesn't need to interpret instructions. It runs the script. Less reading, less reasoning, less token consumption.
The additional benefit: code scripts are more reliable. Natural language instructions leave room for interpretation. "Validate the format" means different things depending on the model's mood. A script that checks isinstance(data, dict) and 'id' in data does exactly one thing, every time.
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 genuinely need flexible interpretation.
Pattern 4: MCP server pruning (the invisible token drain)
Each MCP server connected to your agent loads its tool definitions into the context window. Every message. Every turn. Whether or not you use those tools in this particular interaction.
MindStudio measured the overhead: a single MCP server can cost up to 18,000 tokens per turn in tool definition overhead. Connect three feature-rich MCP servers and you're burning 50,000+ tokens per conversation on tool schemas the agent never calls.
One analysis found that MCP tool definitions can consume 24% or more of the available context window before a single conversation message is sent. That's not a skill costing tokens. That's infrastructure eating your budget.
The fix is simple but often overlooked: unload MCP servers you're not actively using. If today's task doesn't need the GitHub integration, disconnect it. If you only need Slack for 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, which dynamically loads tool definitions only when they'd consume more than 10% of context. But the underlying tension remains. The fewer MCP connections you load, the more context remains for actual work.
This is one area where managed platforms have a structural advantage. On BetterClaw, smart context management handles skill and integration loading automatically. 200+ verified skills are available but only the ones relevant to the current task consume context tokens. No manual MCP pruning. No 18,000-token tool definitions sitting in every message. Free plan with every feature. $19/month per agent on Pro. BYOK with zero markup.
Pattern 5: Context injection over context re-sending
The AI Context Stack pattern (popularized by an open-source GitHub repo in 2026) addresses the most wasteful token pattern of all: re-sending the same project context in every conversation.
Project structure: 800 tokens. Dependencies: 600 tokens. Coding standards: 400 tokens. Architecture decisions: 700 tokens. API docs: 500 tokens. Previous decisions: 400 tokens. Total: 3,400 tokens sent at the start of every single conversation.
Ten conversations per day: 34,000 tokens wasted on repeated context. Monthly: over 1,000,000 tokens that represent zero new information.
The solution: store context in a persistent, efficient format and inject it on demand rather than re-sending it raw every time. This is fundamentally what prompt caching does at the provider level (Anthropic's 90% discount on cached tokens). But you can also implement it at the skill level by structuring your context as compressed, pre-processed summaries rather than raw files.
The pattern: instead of loading your entire project README (2,000 tokens), create a condensed context summary (200 tokens) that captures the critical decisions and conventions. The agent gets what it needs to work correctly in 10% of the tokens. If it needs the full document, it can request it.
The meta-pattern: compound savings
These five patterns don't just add up. They compound.
Output compression cuts per-response tokens by 65-75%. First-pass accuracy eliminates 30-50% of round trips. Code scripts reduce instruction overhead by up to 90%. MCP pruning recovers 24%+ of context window. Context injection eliminates 90%+ of repeated context.
Apply all five and the total reduction is dramatic. A session that would have consumed 150,000 tokens might consume 25,000-40,000. Same work. Same output quality. 75-85% less cost.
Gartner projects 40% of enterprise applications will embed AI agents by end of 2026. As adoption scales, the teams that optimize their token economics today are the ones who can afford to run more agents, more frequently, on harder problems. The teams that don't will hit Uber's wall: budget exhausted before the year is half over.
The best token optimization isn't a single skill. It's a system: compress output, prevent re-prompts, use code over markdown, prune connections, and cache context. Each one saves a little. Together they change the economics. (For the model-selection side of the same problem, see how model routing reduces AI costs and our broader guide to cutting agent API costs.)
Give BetterClaw a look if you want token optimization handled automatically. Smart context management that prevents bloat by design. Free plan with 1 agent and every feature. $19/month per agent on Pro with per-agent cost caps. We handle the token economics. You handle the agent logic.
Frequently Asked Questions
What are token-reducing agent skills?
Token-reducing agent skills are configuration patterns or SKILL.md files that decrease the number of tokens an AI agent consumes per session. They work through five mechanisms: output compression (forcing terse responses, saving 65-75% per message), first-pass accuracy (getting tasks right on the first attempt to prevent costly re-prompts), code scripts over markdown instructions (up to 90% reduction), MCP server pruning (removing unused tool definitions that consume 18,000+ tokens per turn), and context injection (caching repeated context instead of re-sending it).
How much do token-saving skills actually reduce costs?
Individual patterns produce measurable results: output compression saves 65-75% per response (benchmarked by Towards AI), code scripts save up to 90% versus markdown (MindStudio), and MCP pruning can recover 24%+ of context window (Damian Galarza). Applied together, these patterns compound to 75-85% total session reduction. Anthropic's own data shows a task that took 15 messages and 12,000 tokens without a skill took 2 questions and 6,000 tokens with one.
How do I implement an output compression skill for my agent?
Create a skill instruction that directs the agent to use minimal language: no filler phrases, no polite openers, no step-by-step explanations unless explicitly requested. The "Caveman" pattern is the most popular implementation. Add instructions like "respond with maximum information density, no pleasantries, no transitional sentences." Make it toggleable so you can enable full responses when tone matters (customer-facing content, presentations). Average savings: 300-500 token responses compress to 80-150 tokens.
Are token-saving skills worth it on BetterClaw's free plan?
Yes. BetterClaw's free plan includes 100 tasks per month. Token-reducing patterns stretch those tasks further because each task consumes less from your BYOK API budget. Smart context management is built into the platform (no manual MCP pruning needed), and the 200+ verified skills are loaded on demand rather than always present in context. At $19/month for Pro with unlimited tasks, the token savings from proper skill patterns can reduce your monthly API bill by 75-85%.
Can token-saving skills degrade output quality?
Output compression (Pattern 1) reduces explanatory context, which is fine for code generation but can reduce readability for written content. The fix: make compression toggleable. First-pass accuracy (Pattern 2) and code scripts (Pattern 3) improve quality while reducing tokens, so there's no tradeoff. MCP pruning (Pattern 4) only affects tokens, not quality, as long as you keep the servers you actually need connected. Context injection (Pattern 5) can degrade quality if summaries are too aggressive. Start with 50% compression and validate output before going further.
