Superpowers made my Claude Code better and more expensive. Here's what one security update cost.

When I sat down to audit how my Claude Code setup spends tokens, I expected the usual suspects. Too many plugins, a bloated CLAUDE.md, MCP servers nobody uses. Those were there, but they were small.

The big number was somewhere else. It was in the workflow I trust most: Superpowers, the plugin that makes Claude brainstorm, plan, build with test driven development and review its own work. One security update on DogBase produced a 632 KB plan and about 120 subagent runs.

This post is what I found, what those tokens actually bought me, and what I changed. Some of it surprised me. One part made me keep the expensive thing on purpose.

The setup

DogBase is a B2B SaaS for professional working dog teams. This month I moved it from six repositories into one monorepo: a SvelteKit web app, an Expo mobile app, three Go services on Cloud Run and a set of Firebase functions. I build it mostly alone, and Claude writes most of the code.

The workflow is Superpowers. For anything bigger than a small fix it goes like this:

1. Brainstorm the feature into a spec.
2. Turn the spec into a plan, split into small tasks.
3. Hand each task to a fresh implementer subagent, which works test first and commits.
4. Hand the result to a fresh reviewer subagent, which checks it against the plan. If it finds problems, the implementer fixes them and the reviewer looks again.
5. Run a final review over the whole branch.

Fresh subagents are the point. Each one starts clean, so a long session's clutter never leaks into the next task. They are also where the cost lives, because every one of them starts from zero.

One security update in numbers

In October I ran a security update across every app in the repo: Firestore rules, auth and session handling, rate limits, CSP and the customer facing security docs. Superpowers keeps its working files on disk, so afterwards I could measure what it produced. Token counts are estimates at about four characters per token.

• The plan: 632 KB, 62% of it code blocks. Roughly 158,000 tokens.
• Tasks: 60.
• Task briefs handed to implementers: 60 files, 1.43 MB. Roughly 357,000 tokens.
• Diffs handed to reviewers: 69 files, 2.07 MB. Roughly 517,000 tokens.
• Largest single review diff: 1.29 MB, half of it the plan file itself. Roughly 320,000 tokens.
• Tasks that passed their first review: 52 of 60.
• Fix rounds after a failed review: 9, across 8 tasks.
• All working files together: 4.27 MB.

Those are only the files. Every subagent also loads Claude Code's system prompt, its tools, my CLAUDE.md files and the Superpowers skills before it reads a single line of its task.

Where the tokens went

Code in the plan. Superpowers writes plans with the actual code for each step. That makes plans precise, and it means you pay for the code three times. Once when Claude writes it into the plan, and writing is output, the most expensive kind of token. Again when each implementer reads its slice of the plan. A third time when the implementer writes it for real. In my plan, 62% of the text was code.

The briefs. Each implementer got a brief with its task's full text from the plan. They averaged 24 KB, about 6,000 tokens each, before the subagent opened a single file in the repo.

The review diffs. Reviewers read the diff of what the implementer changed. Most were small. One was 1.29 MB because the plan itself had changed in that range, so the reviewer read the plan again as part of the code.

Starting from zero, every time. A subagent is a new conversation. It does not share the main session's prompt cache, and on a subscription its cache lasts five minutes by default where the main session gets an hour. With around 120 implementer and reviewer runs, that fixed startup cost adds up.

A side effect I didn't expect. The plan lives in docs/, so git tracks it. Every time Claude searched the code for a function name, it also found that function's copy inside a 632 KB plan.

What the reviews bought me

My first instinct was to cut the reviews. 52 of 60 tasks passed on the first try, so most reviewer runs found nothing. Then I read the 8 that didn't.

• A login redirect helper could produce //evil.com, an open redirect.
• The Firestore rules were missing a deny for one handler reading another handler's dog, and a deny for groups.
• Signing out after idle time didn't record a revocation, because the session cookie was cleared before sign out could read it.
• A tab could stay signed in forever if the stored last activity time was in the future.
• A rules task had dropped the refusal for crafted queries.
• The customer security docs claimed a protection the code didn't fully give. The reviewer marked it Critical.

The final whole branch review then caught that production indexes had to deploy before the merge, or the insights queries would fail.

That is a security update. Any one of those reaching production would cost me far more than the tokens. So I'm keeping per task review for work like this, and I'm keeping code in plans for now too. When the change is security code, I want to read the exact code in the plan before anything gets built.

The lesson for me wasn't "Superpowers is too expensive". It was to know what each part costs and what it catches, and decide on purpose.

What I changed instead

With the big costs kept on purpose, I went after the waste that buys nothing.

• Twenty design skills became one. My web app had an old copy of the Impeccable design skills checked in as 20 separate skills. Claude sees every skill's name and description in every session, even backend ones. Impeccable is now a plugin with a single skill and 24 commands, so I removed the copies and installed the plugin once, for all my projects.
• Plugins installed once, at user scope. The TypeScript language server was enabled both globally and inside the mobile app. Now it's global only, next to the Go one. With a language server, Claude jumps to a definition instead of searching and opening five candidate files.
• Old plans out of search. A .rgignore file at the repo root lists docs/superpowers/plans/ and docs/history/. Claude Code's search skips those folders, and Claude can still open any plan by path when it needs one.
• Noisy command output trimmed. I installed RTK globally. More on that in the next section, because it came with a catch.
• The cache kept warm on breaks. The cache-tax mod pings my main session before its one hour cache expires, and warns me before I send a message into a cold cache on a big context. The ping is a cache read, a few cents on a large session, against the full price rebuild it saves.
• Junk out of the working tree. Playwright console logs and stray debug files showed up in searches. They are gitignored now.

The tool detour

Test output was an obvious leak. My web app alone has more than 3,800 unit tests. A full run prints a lot, and once that output is in the conversation, it rides along with every message after.

So I built a small hook. When Claude runs npm test or go test, the hook runs it for Claude and hands back only the failures plus a short summary, with the same exit code. On a fake failing run it cut 358 lines down to 41. I packaged it as a plugin.

Then I went looking for prior art. RTK already does this for more than 100 commands, from git to Docker to pytest, and has about 84,000 stars on GitHub. Anthropic's own cost docs even include a sample hook that does what mine did. I dropped mine and installed RTK.

The research also turned up two catches worth knowing before you install it:

1. Rewriting commands changes permissions. RTK and my hook both work by rewriting the command before it runs, so git status becomes rtk git status. Claude Code checks permissions against the rewritten command. Your allow rules can stop matching, so you get more prompts, and one developer reproduced a deny rule being bypassed. Filtering the output after the command runs avoids this.
2. Check your version. Versions before 0.42.2 had a high severity flaw, CVE-2026-54555, where an allowed command could hide a second one that ran without asking. Run rtk --version.

There is also an open debate about whether RTK saves money at all. An issue on its repo reports runs that cost more with it on, because Claude made extra tool calls to make up for the trimmed output. The maintainer says savings depend on how much the output can be compressed. I don't have my own numbers yet.

Small things that still matter

None of these is dramatic on its own. Together they decide what every single request carries.

• Layer your CLAUDE.md files. My root file holds only what applies everywhere, about 1,700 tokens. Each app has its own with its commands and architecture. A web session never pays for the Go services' notes. Anthropic suggests keeping CLAUDE.md under 200 lines and moving workflow instructions into skills, which load only when used.
• Point to docs instead of pasting them. My web app's CLAUDE.md is mostly a table of which doc to read for which feature, so Claude opens the billing doc only when it touches billing.
• Clear between tasks. Claude Code resends the whole conversation on every request. /clear costs nothing. /compact is for when you want to keep going on the same work.
• Pick the model and effort at the start. Switching models mid session throws away the prompt cache, and so does toggling MCP servers. The opusplan setting switches models every time you enter or leave plan mode.
• Look before guessing. /usage breaks down recent usage by skill, subagent, plugin and MCP server, shows your cache hit rate, and suggests fixes. /context shows what fills the window right now.
• Know which mods save tokens and which don't. I run cc-stretch, which collapses long replies so I read less. Its author is clear that it doesn't save tokens: "You read less; you don't pay less." Plenty of mods are about comfort, and that's fine, as long as you don't count them as savings.

A checklist you can copy

If you use Superpowers or any plan and subagent workflow:

• Measure one real feature: plan size, number of tasks, how many reviews found something.
• Decide on purpose whether plans carry full code. It buys precision and costs you the code three times.
• Keep per task review where a missed bug is expensive, like auth, rules and payments.
• Keep plans and archives out of search with a .rgignore.

For any Claude Code setup:

• Run /usage and /context before changing anything.
• Split CLAUDE.md per folder and keep each one short.
• Install plugins and language servers once, at user scope.
• Delete copied skills you don't use. Every description loads in every session.
• If you install RTK, check rtk --version and watch your permission prompts.
• /clear between tasks, and pick your model before you start.

The tokens that matter aren't always the ones that look wasteful. Some of mine were the most useful tokens I spent all month.