# 4 Claude Code Token Savers Tested (One Costs You More)

Video: https://www.youtube.com/watch?v=DeesRYixB-Y
Article: https://aidive.dev/videos/token-saving-stack/
Published: 2026-09-06

## Chapters

- [0:00](https://www.youtube.com/watch?v=DeesRYixB-Y&t=0s) JetBrains says no, my machine says 11.6 million
- [1:02](https://www.youtube.com/watch?v=DeesRYixB-Y&t=62s) Where the tokens actually go
- [2:01](https://www.youtube.com/watch?v=DeesRYixB-Y&t=121s) graphify: walk nodes, not lines
- [3:09](https://www.youtube.com/watch?v=DeesRYixB-Y&t=189s) rtk: the shell proxy on trial
- [4:22](https://www.youtube.com/watch?v=DeesRYixB-Y&t=262s) Superpowers: frame first, then tasks too small to fail
- [5:39](https://www.youtube.com/watch?v=DeesRYixB-Y&t=339s) Superpowers: one task, one subagent, one model that fits
- [6:58](https://www.youtube.com/watch?v=DeesRYixB-Y&t=418s) caveman and the Concise style: say less
- [8:15](https://www.youtube.com/watch?v=DeesRYixB-Y&t=495s) Verdict: what moves the bill, what moves the margins

## TL;DR

- Four free tools promise to save tokens in Claude Code — graphify, rtk, Superpowers and caveman — and only one of them meaningfully moves the bill: Superpowers, because it changes what gets read and which model reads it.
- The two headline numbers everyone quotes measure different things: rtk's 11.6M tokens saved on our machine is bash output bytes, while JetBrains' +7.6% is the end-to-end cost of a completed task.
- Only a fifth of what a Claude Code agent reads is shell output a proxy can compress; a third comes from Read and Grep, which never pass through the Bash hook at all.
- graphify is second: a knowledge graph built locally with tree-sitter, zero LLM credits, 91.8x fewer tokens per query than a naive full-corpus read on our own project.
- caveman's 65% advertised saving measured at 8.5% on agentic work, because an agent's output is mostly code and tool calls; Claude Code now ships the same idea free as the Concise output style.

## JetBrains says no, my machine says 11.6 million

In July 2026 JetBrains spent about $320 of API credit — 425 billed trials — to benchmark rtk, a shell proxy that tens of thousands of developers have installed to save tokens in Claude Code. The verdict: sessions came out 7.6% more expensive per task. Two weeks earlier the same team had measured caveman, the skill advertised as cutting 65% of tokens, and got 8.5%. On my own machine, `rtk gain` reports 11.6 million tokens saved over 25,599 commands.

Both sets of numbers are real. They do not measure the same thing: one is cost per completed task, the other is bash output bytes.

| Number | What it measures | Source |
|---|---|---|
| +7.6% per task (p=0.004) | End-to-end cost of a task with rtk installed | JetBrains, 425 trials, ~$320 |
| 8.5% of output tokens | caveman's measured saving on agentic work | JetBrains, 82 paired tasks |
| 65% | caveman's advertised saving | caveman README |
| 11.6M saved (41.6%) | Bash output bytes compressed by rtk | `rtk gain`, 25,599 commands |

This is the stack four tools deep — graphify, rtk, Superpowers and caveman — 575,612 GitHub stars between them on 2026-09-02. Each one touches a different slice of the bill.

| Tool | Stars (2026-09-02) | Language | License |
|---|---|---|---|
| Superpowers | 280,792 | Markdown skills | MIT |
| graphify | 113,946 | Python | Apache-2.0 |
| caveman | 102,548 | Go | MIT (skill) |
| rtk | 78,326 | Rust | Apache-2.0 |

## Where the tokens actually go

A Claude Code bill has two sides. **Input tokens** are everything the model reads: the output of every shell command, your prompt, the system prompt, and the whole conversation history replayed on every call. **Output tokens** are everything the model writes.

rtk's own documentation draws exactly that tree, and adds a sentence its launch post never had: "A command showing 90% fewer output bytes does not make your session 90% cheaper."

JetBrains put numbers on the reading side by replaying 83 baseline sessions, 1.9 million characters of tool output.

| Slice of what the model reads | Characters | Share |
|---|---|---|
| Shell output rtk can compress | 373,339 | 19.7% |
| Shell output rtk has no rule for | 879,326 | 46.3% |
| File reading and search tools that skip rtk entirely | 646,613 | 34.0% |

Only a fifth of what the model reads is compressible by a shell proxy at all — Claude Code's built-in `Read`, `Grep` and `Glob` tools never pass through the Bash hook.

That gives the map for the four tools: graphify shrinks what the agent reads, rtk shrinks what the shell sends back, Superpowers shrinks the history each task carries and picks which model carries it, and caveman shrinks what the agent says. The reading side is the bigger half of the bill, so that is where the ranking starts.

## graphify: walk nodes, not lines

**graphify** is a skill that turns a codebase — with its docs, SQL schemas, configs and PDFs — into a queryable knowledge graph. You type `/graphify .` in Claude Code, Cursor, Codex or Gemini CLI, and the project is mapped once so the agent can query the graph instead of grepping through files.

Code is parsed with tree-sitter AST across roughly 40 languages: deterministic, no LLM call, nothing leaves the machine. The build costs zero LLM credits. It produces three files: `graph.html` to click through, `GRAPH_REPORT.md`, and `graph.json` — the graph itself, queryable without re-reading your files. Every node is a concept (a file, a function, a class), and every edge is tagged `EXTRACTED` when it was explicit in the source or `INFERRED` when graphify resolved it. Nodes are clustered into subsystems with the Leiden algorithm.

Running the built-in benchmark on one of our own projects:

| Metric | Value |
|---|---|
| Nodes | 34,031 |
| Edges | 56,865 |
| Communities detected | 967 |
| Edge provenance | 76% EXTRACTED · 24% INFERRED |
| Naive full-corpus read | 1,701,550 words ≈ 2,268,733 tokens |
| Average graph query | ~24,702 tokens |
| Reduction | 91.8× fewer tokens per query |

Per question the spread is wide: 679.1× on "what is the main entry point", 34.0× on "what connects the data layer to the api".

Two limits. That comparison is against reading everything, and a grep-driven session was never that expensive, so the real gain is smaller. And the graph goes stale — refresh it with `graphify update <path>`, `--watch`, or the git hooks — while the semantic pass over docs, PDFs and images does call a model and does spend tokens.

Install: `uv tool install graphifyy` (the package name carries a double y), then `graphify install`.

## rtk: the shell proxy on trial

**rtk** is a CLI proxy between Claude Code and your shell. Plain commands like `ls`, `cat` or `git status` return noise the agent has to read as input tokens — file permissions, progress bars, a hundred passing test lines. rtk runs the same command and hands back a compact version: a single Rust binary, 100+ supported commands, under 10 ms of overhead. A `PreToolUse` hook rewrites every eligible Bash call (`git status` → `rtk git status`) before it runs, so the agent never has to remember it.

The author's launch post claimed 10.2M tokens saved in two weeks, 89.2%, with examples like `cargo test` going from 155 lines to 3. Our own dashboard after 25,599 commands:

| Command | Calls | Tokens saved | Rate |
|---|---|---|---|
| `rtk find` | 354 | 2.2M | 46.6% |
| `rtk read` | 3,504 | 2.2M | 10.4% |
| `rtk grep` | 2,760 | 1.9M | 47.7% |
| `rtk ps aux` | 24 | 1.1M | 98.0% |
| `rtk diff` | 39 | 541.1K | 92.2% |
| **Total** | **25,599** | **11.6M** | **41.6%** |

Then the trial. JetBrains installed rtk exactly as it ships and ran 86 tasks twice on claude-sonnet-5.

| JetBrains finding | Value |
|---|---|
| Shell commands rtk can rewrite | 349 of 1,056 (1 in 3) |
| Ceiling on total saving | ~3% of the bill |
| Cost per task, low reasoning effort | +7.6% (p=0.004) |
| Turns per task | +13.8% (p=0.03) |
| Cost per task, high effort | ±0% |
| Task quality | Unchanged |

The rtk README now states it plainly: up to 90% of the bash output, "not the same as cutting your bill by 90%", and its own counts are estimated as `bytes / 4`.

Verdict: it is free, the compression is real and, in JetBrains' words, "often tasteful". Keep it for bash-heavy sessions; do not expect it to move the bill.

## Superpowers: frame first, then tasks too small to fail

**Superpowers** is Jesse Vincent's plugin for Claude Code — 280,792 stars, fourteen skills, one install command (`/plugin install superpowers@claude-plugins-official`). It saves tokens without compressing anything.

Everything starts with the brainstorming skill, which opens on a hard gate: no code, no scaffolding, no implementation skill until an explicit intent is approved. When the skill loads the agent becomes a brainstorming partner, and in practice pieces of the project get rethought before anything is built. That is the stage that matters most, because the most expensive tokens are the ones spent building the wrong thing.

The skill classifies the work as a spike, a bounded change, or an architectural one, and the rule is written into the file: "When in doubt between two paths, take the heavier one." It even names the failure mode — an anti-pattern section titled "Too Simple To Need Approval". The architectural path produces a spec you validate, then an implementation plan.

The plan is where reliability comes from. The writing-plans skill cuts the work into steps of one action each, 2 to 5 minutes: write the failing test, run it to confirm it fails, write the minimal code that passes, run the tests again, commit. Plans are written assuming the engineer has zero context. A task that small fits in a fresh context window with room to spare, so the agent never reaches the end of a task with a saturated window — and a saturated window is where hallucinated code comes from.

The limit is the ceremony. The file says it scales with the task, but the gate still fires on a one-line fix, and that costs tokens too.

## Superpowers: one task, one subagent, one model that fits

Then the plan runs, and the token math changes. One task, one subagent. Each subagent starts with a fresh context holding only its task, never the session history, so the orchestrator's window stays small and the subagent's stays clean. After every task the orchestrator reviews the result: OK, next task; not OK, a fix goes back to a subagent. Five rounds maximum per task — rounds 1 to 3 resume the original implementer, round 4 hands the work to a fresh implementer on a more capable model, round 5 the orchestrator rules itself.

The rule that pays for everything is model selection: "Use the least powerful model that can handle each role to conserve cost." The orchestrator rates each task's difficulty and picks a model to match.

| Task type | Model tier |
|---|---|
| Mechanical, well-specified; plan already contains the code | Cheapest / small model |
| Multi-file coordination, debugging | Standard model |
| Architecture, final branch review | Most capable model |
| Model omitted | Inherits the session's model |

One nuance from the same file: "Turn count beats token price." A cheap model that takes three turns is not cheap. In practice this is what makes Opus and Fable usable on a $20 Pro plan — the expensive model touches a handful of tasks instead of the whole session.

The last win is documentation. Every spec and plan is a markdown file saved to `docs/superpowers/specs/` and `docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md`, committed at the end of the work. On this channel's own pipeline, the migration to our current video engine is a spec plus a fourteen-task plan you can still open, mention in a new session, and build on. Nothing the agents did is untracked.

## caveman and the Concise style: say less

The last slice is what the agent says. Agents narrate — "sure", "happy to help", "the issue you're experiencing is likely caused by" — and that is output tokens for nothing.

**caveman** is a skill by Julius Brussee, 102,548 stars, that makes the agent talk like a caveman: drop articles, filler, pleasantries and hedging, and follow the pattern `[thing] [action] [reason]. [next step].` Code, commands, file paths and exact error messages are never cavemanned; only the prose around them is. It ships three levels (`/caveman lite|full|ultra`) and a SessionStart hook that turns it on at startup.

Its own table, ten prompts through the Claude API, averages 1,214 output tokens without the skill and 294 with — 65%, with a best case of 87% and a worst case of 22%.

The README supplies the reality check itself: the skill only shortens output, input and reasoning tokens do not change, and its own rules cost about 1–1.5k input tokens every turn. JetBrains measured it on 82 paired agentic tasks at about $106 of credit.

| caveman | Advertised | Measured (JetBrains) |
|---|---|---|
| Output token saving | 65% | 8.5% (592k → 542k) |
| Quality impact | — | No detectable degradation (sign test p=0.82) |

The gap is structural: an agent's output is mostly code and tool calls, which caveman correctly leaves alone. JetBrains' recommendation: "use it if you like it. It is fun, and it costs you nothing measurable in quality."

Since Claude Code v2.1.237 there is a built-in equivalent, the **Concise output style**: Claude "leads with the result, skips preamble and narration, and keeps responses short by default." Pick it in `/config` → Output style; it is saved to `.claude/settings.local.json` and takes effect after `/clear` or a new session. One limit both share: output styles apply to the main conversation only — a subagent runs its own system prompt.

## Verdict: what moves the bill, what moves the margins

Ranked by what each tool actually moves, with the cost each one carries.

| Rank | Tool | What it moves | Measured effect | The cost |
|---|---|---|---|---|
| 1 | Superpowers | History per task + which model reads it | Expensive model on a handful of tasks instead of the session | A gate on every task, even one-line fixes |
| 2 | graphify | What the agent reads | 91.8× fewer tokens per query vs a naive full-corpus read (our project) | Graph goes stale; the semantic pass spends tokens |
| 3 | rtk | Bash output bytes | Ceiling ~3% of the bill; +7.6% per task at low effort in JetBrains' test | Only 1 in 3 shell commands has a rule |
| 4 | caveman / Concise | Prose the agent writes | 8.5% of output tokens, no quality loss | ~1–1.5k input tokens every turn |

Superpowers wins and not because of any compression: a fresh context per task and the cheapest model that can do the job change what gets read and who reads it. graphify is second because reading less is the bigger half of the bill. rtk is real, free and harmless, but two-thirds of shell commands and every file read bypass it. caveman, or the Concise style now shipped in Claude Code, trims the smallest slice.

All four are free to install — graphify and rtk under Apache-2.0, Superpowers under MIT, the caveman skill under MIT. More than 570,000 stars say people want a miracle. The honest version is a ranking.

## FAQ

### What is the best way to save tokens in Claude Code?

Change what the agent reads and which model reads it, rather than compressing text. The Superpowers plugin gives each task a fresh subagent context that holds only that task, and assigns the least powerful model that can handle it. That moves far more of the bill than any output compressor.

### Does rtk actually reduce Claude Code costs?

Barely. Its compression of shell output is real, but JetBrains found only 1 in 3 shell commands has a rule and only a fifth of what the model reads is compressible at all, capping the saving around 3% of the bill. In their 86-task A/B run rtk came out 7.6% more expensive per task at low reasoning effort and identical at high effort, with unchanged quality.

### Why does rtk report millions of tokens saved if it does not lower the bill?

rtk counts bash output bytes it removed, estimated as bytes/4, not money. Our own dashboard shows 11.6M tokens saved (41.6%) over 25,599 commands. rtk's own documentation says it directly: a command showing 90% fewer output bytes does not make your session 90% cheaper.

### What is graphify and does it save tokens?

graphify is a /graphify skill that parses a codebase locally with tree-sitter into a queryable knowledge graph, with no LLM call and zero credits for the build. The agent then walks logical nodes instead of grepping files. On our project the built-in benchmark measured 91.8x fewer tokens per query than reading the whole corpus, though that baseline is a naive full read, not a grep-driven session.

### Is the caveman skill worth installing?

Only if you enjoy it. It advertises a 65% cut but JetBrains measured 8.5% of output tokens across 82 paired tasks, with no detectable quality loss, because code and tool calls are correctly left untouched. Its own rules also add about 1 to 1.5k input tokens every turn.

### What is the Concise output style in Claude Code?

A built-in output style available since Claude Code v2.1.237 that makes Claude lead with the result, skip preamble and narration, and keep responses short. You pick it in /config, it is saved to .claude/settings.local.json, and it applies to the main conversation only — subagents keep their own system prompt.

### How does Superpowers make Opus or Fable usable on a $20 plan?

Its subagent-driven-development skill tells the orchestrator to use the least powerful model that can handle each role: a small model for mechanical, well-specified tasks, a standard model for multi-file work and debugging, and the most capable model only for architecture and the final review. The expensive model touches a handful of tasks instead of the entire session.

## Sources

- [Does rtk really save tokens in Claude Code?](https://blog.jetbrains.com/ai/2026/07/rtk-claude-code-token-savings/) — JetBrains
- [Speak to AI agents like cavemen to save tokens](https://blog.jetbrains.com/ai/2026/07/speak-to-ai-agents-like-cavemen-tosave-tokens/) — JetBrains
- [How RTK savings work](https://github.com/rtk-ai/rtk/blob/master/docs/guide/resources/savings-explained.md) — GitHub
- [rtk-ai/rtk on GitHub](https://github.com/rtk-ai/rtk) — GitHub
- [Graphify-Labs/graphify on GitHub](https://github.com/Graphify-Labs/graphify) — GitHub
- [obra/superpowers on GitHub](https://github.com/obra/superpowers) — GitHub
- [JuliusBrussee/caveman on GitHub](https://github.com/JuliusBrussee/caveman) — GitHub
- [Output styles](https://code.claude.com/docs/en/output-styles) — Claude Code docs