AI coding agents are useful because they read code, plan changes, run commands, inspect errors, and iterate. That is also why they get expensive. The bill is not only the final answer. You pay for prompt context, tool results, repeated file reads, hidden reasoning or thinking where applicable, and output tokens.
Quick answer
Token-saving skills such as Caveman can reduce verbose output, but they are not the main cost lever. The better stack is: keep agent replies concise, keep repo context small, reuse compact project memory, route simple tasks to cheaper models, and convert repeated workflows into scripts or replayable skills.
The three token buckets
Before installing any skill, separate the bill into three buckets. Output compression only touches one of them.
| Bucket | What it includes | Best reduction strategy |
|---|---|---|
| Input tokens | Your prompt, repo context, tool output, skill instructions, logs | Smaller context, better file selection, compact project memory |
| Reasoning / thinking | Model-internal reasoning budget where exposed or billed | Task scoping, simpler model routing, fewer retries |
| Output tokens | The agent's visible answer, summaries, explanations, plans | Concise response mode, Caveman-style compression, shorter reporting |
Where Caveman helps
Caveman is a popular skill/plugin that makes coding agents answer in a compressed, low-filler style while preserving code, commands, and errors. That can be useful when an agent tends to narrate every step or produce long summaries after every action.
The important caveat is in Caveman's own documentation: it mainly shrinks output tokens. Input and reasoning tokens are not reduced, and the skill itself can add roughly 1-1.5K input tokens per turn. That means it can save money in verbose, output-heavy workflows, but it can lose money in short or already terse sessions.
What independent testing suggests
Treat large token-saving claims carefully. JetBrains tested Caveman-style prompting on real agentic tasks and reported a much smaller measured saving than headline claims: about 8.5% in their broader run, not 65%. That does not make the idea useless. It means output compression is a small-to-medium optimization, not a full cost strategy.
Skills can also increase token use
Skills are not free. A skill is usually extra instructions injected into the model's context. A 2026 SkillReducer paper studied tens of thousands of agent skills and found systemic inefficiency: many skills lacked good routing descriptions, much of the body content was non-actionable, and reference files could inject very large token loads.
The useful lesson is not "avoid skills." It is "route skills carefully." A good skill should have a short trigger description, a compact core, and optional references loaded only when needed. That maps directly to how WhichAI now thinks about workload selection: use the expensive context only when the task actually needs it.
The bigger savings: stop rediscovering the repo
Coding agents waste a lot of tokens re-learning the same project structure. If every session starts by searching folders, reading package files, opening config files, and reconstructing architecture, you are paying for repeated context discovery.
- Keep a compact repo map: major directories, data files, routing conventions, test commands, deployment notes.
- Give task-local context: point the agent to the specific files or feature area instead of asking it to search the whole repo.
- Summarize decisions: after a major change, keep a short decision log so the next session does not re-derive it.
- Limit logs: paste the failing section, not the full terminal scrollback unless the full context is necessary.
Model routing beats one-model-for-everything
A premium model is often worth it for hard implementation, architecture decisions, and subtle bug fixes. It is wasteful for file inventory, simple summarization, routing, changelog drafting, and repetitive transforms.
| Task | Recommended route |
|---|---|
| Find files, summarize logs, classify errors | Cheap/fast model |
| Implement complex code change | Strong coding model |
| Review security or architecture tradeoffs | Frontier-quality model |
| Repeat the same workflow every day | Script, CI job, or deterministic replay |
Use the AI API pricing calculator to compare the monthly effect of routing. A small model handling half of the simple turns can matter more than compressing the final answer by a few percent.
Deterministic replay is the strongest form of savings
If a task is repeated and stable, the cheapest agent call is no agent call. A 2026 LOOP Skill Engine paper describes recording a successful tool-call trajectory once, then replaying future runs deterministically with parameters. The paper reports very large token reductions for periodic tasks because later runs bypass full LLM reasoning.
You do not need that exact system to use the idea. In normal development, this means turning repeated agent behavior into scripts, test commands, codemods, checklists, or CI workflows.
A practical developer stack
| Layer | Tool or practice | When to use it |
|---|---|---|
| Output compression | Caveman-style concise replies | Verbose coding agents, long summaries, output-heavy sessions |
| Context hygiene | Repo map, focused file list, short decision log | Every medium or large codebase |
| Skill hygiene | Short routing description, progressive disclosure | Teams with many custom skills or prompts |
| Model routing | Cheap model for simple steps, strong model for hard steps | API-backed agents and multi-model workflows |
| Deterministic workflows | Scripts, CI, codemods, replayable tasks | Repeated operations with stable inputs |
Source and verification
This guide was written from public project documentation and independent measurement rather than headline savings claims. Sources checked on July 17, 2026 include the Caveman GitHub documentation, JetBrains' Caveman test write-up, the SkillReducer paper on agent skill token efficiency, and the LOOP Skill Engine paper on deterministic replay for repeated agent tasks.
- Caveman GitHub repository — output-token focus and input-token caveats.
- JetBrains Caveman test — measured savings on real agentic tasks.
- SkillReducer paper — skill routing/body compression and progressive disclosure.
- LOOP Skill Engine paper — deterministic replay for repeated agent tasks.
Frequently asked questions
Do token-saving skills like Caveman really reduce AI coding agent costs?
They can reduce output tokens, but they do not reduce input or reasoning tokens. Caveman itself warns that the skill can add roughly 1-1.5K input tokens per turn, so it can be net-negative on already terse workloads.
What is the biggest way to reduce coding agent token costs?
Control input context, avoid repeated repo exploration, route simple work to cheaper models, and turn repeated workflows into scripts or deterministic replay.
Should every developer install token-saving skills?
No. Install them when output is genuinely verbose. If your agent already gives short answers, focus on context size and model routing first.