Finds the part of your Claude Code spend that didn't need to happen.
ccusage and its siblings will tell you exactly what you spent — down to
the token. They will not tell you whether you needed to. That second
question requires reading what the task actually was, and that's the layer
a stats tool structurally can't provide. Overkill is that layer.
overkill report
Two runs, same session that built this tool, about ninety minutes apart — including the parts that show the tool's real limits, not just its wins.
Run 1 — usage-only mode (no content access, just ccusage):
OVERKILL — active block (2026-07-09, 07:00–12:00)
Total spend: $16.75 across 40.85M tokens, 123 entries, claude-sonnet-5
Projected: $28.69 by end of block
token shape: 95.0% cache reads, 4.5% cache writes, 0.45% fresh output
effort-level mismatch needs session content, not just usage numbers, to
verify honestly. ccusage doesn't expose per-task effort level. this is
what the usage layer alone can tell you.
Run 2 — full mode, ~90 minutes later, with real conversation content:
OVERKILL — active block (2026-07-09, 07:00–12:00, in progress)
Total spend so far: $31.77 across 87.9M tokens, 335 entries
Burn rate: $10.04/hr — up from $6.07/hr an hour ago, accelerating
token shape: 96.1% cache reads (up from 95.0%)
flagged — overkill, real and specific:
two heavyweight, multi-agent-dispatch skills got invoked and then
abandoned mid-load once it was clear they were built for large-codebase
team engineering, not this task. real, true, and specifically
identifiable in the transcript — but NOT precisely priced, see below.
flagged — slow failure, real and specific:
one fix (a Python package install) tried the cheap path three times
before switching to the approach that worked immediately.
not flagged, and the actual biggest finding both times:
the dominant cost driver is the 96.1% cache-read ratio — not a bad
task, session length. no single decision caused it.
What Overkill got right here: named two real overkill instances and one real slow-failure instance, correctly, from actual conversation content — not guessed from token counts.
What Overkill could not honestly do: attach a precise dollar figure to
either flagged item. ccusage reports cost at the block/session level, not
per-invocation — so "this specific skill call cost $X" isn't data Overkill
has access to yet. Any dollar amount for an individual flagged item is a
rough, proportional estimate, and the tool says so explicitly rather than
presenting a specific-sounding number it can't back. See Known
limitations below before you trust a dollar figure from this tool as
precise.
Given session transcripts (or a description of what was worked on), Overkill goes further than the usage-only mode:
- Pulls real usage data via
ccusage— reused, not duplicated - Reads what each task actually was
- Classifies complexity: trivial / standard / complex
- Flags overkill (heavier tier or mechanism than the task needed) and slow failure (cheap tier retried repeatedly before escalating — often costs more than getting it right the first time)
- Labels every dollar figure by precision — measured when the harness exposes per-call cost, estimated (proportional, and says so) when it only has block-level totals
- Hands back a routing policy for your
CLAUDE.mdgrounded in what your real flagged items actually were — never a generic template
Because the dashboard shows you a number and stops. The number alone doesn't tell you if it's a good number — $200 on genuinely hard, correctly-tiered work is money well spent. $200 where a third of it was formatting run at maximum reasoning effort is not, and no cost dashboard can tell the difference, because that difference lives in what the task was, not in what it cost.
Installing the skill does nothing by itself. A skill file can't wake itself up — nothing executes until something triggers it. True of every skill in this ecosystem, not a limitation specific to this one.
The first time you ever run it — for any reason — it offers to set up
its own recurring check, right then. So the real workflow is: install,
run overkill report once (which you'd probably do anyway, to see it
work), say yes, done. One manual trigger, ever — not one every time you
want it to keep checking.
overkill report
→ [real report] ...
→ "want me to check this automatically from now on? I'll run a cheap
daily check and only bother you above $5 or 20% flagged waste. set
it up?"
→ yes
Whether that means persistent-forever or session-bound depends on your
harness, and it states which, plainly, at setup. Claude Code CLI's
/schedule persists independently of any open session. Some other
environments only support recurring jobs scoped to the current session,
often with a hard expiry (e.g. 7 days) regardless of activity.
Not the model getting smarter — that would be a claim this tool exists to
catch elsewhere, so it doesn't get a pass here either. What actually
happens: a local file (~/.overkill/history.md) that records when
you correct a classification, and consults those corrections on future
runs. Also tracks whether a recommended fix actually got adopted, and
whether spend in that category dropped afterward — checked against
reality, not assumed. Empty history file means it says so and classifies
from base rules, not from learning that hasn't happened yet.
Claude Code / any Agent Skills host:
npx skills add iamtural/overkill -g
Requires ccusage (auto-invoked via
npx, no separate install needed) for the raw usage layer.
Manual: copy skills/overkill/ into your harness's skills directory
(e.g. .claude/skills/).
Usage-only mode works everywhere, today, with zero extra setup. Full content-correlated mode needs session transcripts to be readable — works out of the box on harnesses that store them on disk; on others, point it at what you worked on and it classifies from your description instead.
Dollar figures for individual flagged items are estimates, not measured
facts, in v1. ccusage (and the other CLI usage tools it wraps) reports
cost at the block or session level — it does not expose what any single
tool call or skill invocation cost on its own. Overkill can tell you what
looked like overkill with real confidence, because that comes from reading
actual content. It cannot yet tell you precisely how many dollars that
specific thing cost, because the pricing data isn't that granular anywhere
in the pipeline it reads from. Every dollar figure in a report says
whether it's measured or estimated — trust the label, not just the number.
This closes once a harness exposes per-invocation cost; nothing about the
skill's design blocks it, the data just isn't there yet.
Task classification is judgment, not a formula. Two people could classify the same task differently. Overkill states its reasoning for every classification so you can disagree with a specific call — it is not a black box handing down verdicts.
MIT