# Your AI-tool usage is invisible. Here are 4 tiny local tools to see it. > Source: > Published: 2026-06-25 15:49:11+00:00 You use Claude Code, or ChatGPT, or both, every day. Quick question: how many messages did you send last month? Which model ate most of your budget? How much did prompt caching actually save you? You don't know. I didn't either. That's a weird gap. We instrument *everything* else — git activity, deploy frequency, test coverage — but the tool we now spend the most hours inside is a black box. The vendor dashboard, if it exists, is a billing page, not a mirror. So I built four tiny tools to fix that for myself. They all run **100% locally**. No accounts, no API keys, no telemetry, no network calls. They read files that are already on your disk and print something you can look at. All four are open source on [github.com/greymoth-jp](https://github.com/greymoth-jp) — and because that's a real claim, the only thing I'll ask is that you **grep the source yourself** before you trust me. Here's the privacy point up front, because it's the whole design: these read your data, but your data never leaves your machine. That's not a feature I'm bolting on for a marketing line. It's the reason the tools are small enough to audit in one sitting. Before the tools, here's what I assumed: my Claude Code bill is dominated by the prompts I write, so to spend less I should write tighter prompts. Compress the context. Trim the system message. The usual advice. I ran the numbers on my own `~/.claude` transcripts and got this: | component | share of cost | |---|---| | cacheRead | 72% | | cacheWrite | ~19% | | output | the rest | input | ~0.3% | Input — the thing everyone tells you to compress — was **0.3%** of my spend. Compressing my prompts to save money would've been optimizing the rounding error. Worse: compressing a *static* prompt changes its bytes, which busts the prefix cache, which can make the bill go **up**. The real cost center was cache reads: long sessions dragging a fat context forward, turn after turn. That points at completely different levers — cache hygiene (milestone `/compact` , `/clear` before the context balloons, keeping `CLAUDE.md` static so it doesn't bust the cache), and routing a whole mechanical session to a cheaper tier *at the boundary*, never mid-session. **Important honesty caveat:** that 72% is *my* number, from *my* usage, and the dollar figures are estimates against published rates. Yours will be different. If you're on a Max/Pro plan it's "value extracted," not literal spend. The point isn't the specific percentage — it's that **you can't reason about a cost you've never measured.** Measure first, then optimize. The tool below does the measuring. All open source, all local, all MIT-licensed. Two are npm CLIs; one is a browser extension; one reads public data only. `tokenops` — Claude Code cost truth The one that produced the table above. It reads `~/.claude` , breaks your spend down by component and by model, and then gives you **data-validated** advice — not generic tips, but actions ranked by the dollars *your* profile says are on the table. ``` npx @greymoth/tokenops demo # synthetic data — try it with zero risk first npm i -g @greymoth/tokenops tokenops report # cost by component + by model tokenops advise # prioritized, $-quantified actions tokenops card # a shareable Before→After card (--anon hides project names) ``` → ** github.com/greymoth-jp/tokenops** · npm: `@greymoth/tokenops` Start with `tokenops demo` — it runs on synthetic data so you can see exactly what it does before pointing it at your own transcripts. `ccwrapped` — your Claude Code "Wrapped" card Same `~/.claude` data, different job. Where `tokenops` is the spreadsheet, `ccwrapped` is the poster: messages, estimated value, top model, top project, and how much caching saved you — rendered as a self-contained SVG you can screenshot and share. ``` npm i -g @greymoth/ccwrapped ccwrapped --wrapped # writes an SVG — open in a browser, screenshot, share ccwrapped --wrapped --anon # same, with project names hidden for a clean public share ``` → ** github.com/greymoth-jp/ccwrapped** · npm: `@greymoth/ccwrapped` My own card said ~194,379 messages and a prompt-caching figure in the six figures of *estimated* equivalent value. Again — that's my year, not a benchmark. The fun part is that yours is a surprise even to you. `inkdex` — ChatGPT + Claude usage, in the browser Not everyone lives in a terminal. `inkdex` is a Manifest V3 browser extension that tracks your ChatGPT and Claude *web* usage locally and prints a risograph Wrapped card. No account, and **nothing leaves your browser** — it's all in extension storage. → [github.com/greymoth-jp/inkdex](https://github.com/greymoth-jp/inkdex) `ghwrapped` — any public GitHub profile → a shareable card The odd one out: it doesn't read your private data because it doesn't need to. Feed it any public GitHub username and it renders a risograph Wrapped card from **public data only**. Good for a year-in-review, a profile README, or sizing up a repo you're about to depend on. → [github.com/greymoth-jp/ghwrapped](https://github.com/greymoth-jp/ghwrapped) I keep saying these send nothing. You shouldn't take that on faith from a stranger on the internet — that's the entire point of shipping the source. So: `bin/` in `grep -rEi 'fetch|http|net\.|request|axios' .` in the cloned repo. If a usage analyzer is opening a socket, you'll see it.That's the difference between *trust me* and *verify me*, and it's the only kind of privacy claim worth making. Here's the actual ask, and it's the fun one: `npm i -g @greymoth/ccwrapped` `ccwrapped --wrapped --anon` (the `--anon` hides your project names, so it's safe to post)I genuinely want to see the spread. My caching savings looked absurd; maybe yours dwarf mine, maybe you barely cache at all and that itself is the finding. Either way you'll learn something about a tool you use every day and have never actually looked at. And if you find a bug, or a place where one of these *does* touch the network when it shouldn't — open an issue. Catching that is the best possible outcome, because it proves the "grep it yourself" model works. Repos, one more time, all under one roof: ** github.com/greymoth-jp** → `ccwrapped` , `tokenops` , `inkdex` , `ghwrapped` .Go measure the thing you can't see. Then come back and show me the card.