Last month I decided to track every single dollar I spent on AI coding tools. Not just subscriptions — actual per-request token costs, model usage breakdowns, the whole thing.
The results genuinely surprised me. Here's what 30 days of data revealed.
The Setup
I'm a solo macOS developer building two apps: a menu bar token cost tracker called TokenBar ($5) and a feed-level distraction blocker called Monk Mode ($15). I use Claude Code, Cursor, and direct API calls daily.
To track costs, I used TokenBar itself (eating my own dog food) which sits in my Mac menu bar and shows real-time token costs for every AI request. I also logged everything in a spreadsheet as a backup.
The Numbers
Total spent in 30 days: ~$847
Here's the breakdown:
| Category | Monthly Cost | % of Total |
|---|---|---|
| Claude Code (Max plan) | $200 | 23.6% |
| Cursor Pro | $20 | 2.4% |
| Direct API calls (Claude) | $412 | 48.6% |
| Direct API calls (GPT-4o) | $127 | 15.0% |
| Direct API calls (misc) | $88 | 10.4% |
5 Things That Shocked Me
1. My most expensive single session cost $43
One debugging session where I kept feeding entire codebases to Opus for architectural advice. The fix took 10 minutes once I found it. The token cost of finding it? Forty-three dollars.
Lesson: Real-time cost visibility changes everything. Once I could see the meter running (literally, in my menu bar), I started being much more intentional about which model I used for what.
2. 80% of my API costs came from 12% of my requests
A tiny fraction of "heavy" requests — mostly large context windows and Opus-tier reasoning — ate up the vast majority of my budget. The other 88% of requests were cheap Sonnet/Haiku calls that barely registered.
This maps perfectly to what Chamath was saying about the bi-modal distribution in Claude usage. There's a small number of expensive operations and a massive long tail of cheap ones.
3. I was using Opus for tasks Haiku could handle
This was the most embarrassing finding. About 30% of my Opus API calls were for things like "format this JSON" or "write a unit test for this function." Haiku does those just as well for 1/60th the cost.
Once I started consciously routing tasks by complexity:
- Haiku: Formatting, simple generation, boilerplate
- Sonnet: Implementation, refactoring, code review
- Opus: Architecture decisions, complex debugging, novel problem-solving
My API bill dropped from $627 to $412 in the second half of the month. Same output quality.
4. The subscription plans actually saved me money
Claude Code Max at $200/month sounds steep. But when I calculated what those same requests would have cost at API rates, it was closer to $800-900. The subscription is essentially a 75% discount if you're a power user.
The catch is you have no idea how much you're actually consuming unless you track it independently. Which brings me to...
5. Zero tools gave me cost visibility by default
This was the realization that actually led me to build TokenBar. None of my coding tools — not Cursor, not Claude Code, not the API dashboard (which updates hours later) — gave me real-time, per-request cost information.
It's like driving a car with no speedometer. You know you're burning gas, but you have no idea how fast.
The Productivity Tax Nobody Talks About
Here's the thing nobody in the "AI tools are so cheap" discourse mentions: distraction cost.
During this experiment I also tracked my screen time. On days when I was deep in AI-assisted coding, I'd inevitably "take a break" and open Twitter/Reddit/HN. Those breaks averaged 47 minutes. Per break. Multiple times a day.
The direct AI costs ($847/month) were actually less than the productivity cost of context-switching to social media feeds between coding sessions. I calculated the lost productivity at roughly $2,000-3,000/month in opportunity cost.
That's what led me to build Monk Mode — it blocks the algorithmic feed sections of social media apps while keeping the useful parts (DMs, search, posting). Not the nuclear option of blocking entire apps, just the infinite scroll trap.
Since using it, my average coding session length went from 45 minutes to 2+ hours before breaking. Not because I have more willpower, but because the distraction simply isn't there when I reflexively open Twitter.
What I'd Tell Every Dev Using AI Tools Right Now
Track your actual costs. Not your subscription fee — your real per-request spend. You'll be shocked at the distribution.
Route by model tier. Use the cheapest model that gets the job done. This alone can cut API costs 40-60%.
Your biggest cost isn't tokens — it's attention. Every context switch to a social media feed costs you 20+ minutes of recovery time. The feed is the problem, not the app.
Real-time feedback loops change behavior. When I could see token costs ticking up in real time, I naturally became more efficient. Same principle as seeing your electricity usage on a smart meter.
The subsidy era won't last forever. Anthropic is currently eating massive losses on power users. When that changes, the devs who already optimized their usage patterns will barely notice. Everyone else will panic.
Tools I Actually Use Now
- TokenBar ($5, Mac) — Real-time token cost tracking in the menu bar. I built this because nothing else existed.
- Monk Mode ($15, Mac) — Blocks social media feeds while keeping DMs/search. My secret weapon for deep work.
- Claude Code Max ($200/month) — Worth it if you're a power user, but track your usage.
- A simple spreadsheet — For the weekly cost review ritual. 15 minutes every Sunday.
The Bottom Line
The discourse around AI coding costs is missing two things: granular visibility and the hidden attention tax. Most devs have no idea what individual requests cost them, and most are losing more money to doomscrolling between coding sessions than they are to token prices.
Fix those two things and you'll ship faster, spend less, and actually enjoy the process.
Building both of these tools as a solo dev. Happy to answer questions about the tracking methodology or the build process in the comments.
Top comments (0)