You are not
using a chatbot.
Ninety-eight days of local transcript data says you operate Claude as autonomous infrastructure — long specs in, thousands of tool calls out, subagents fanning underneath. Here is every number I could actually measure, the metric board an agent-product team would grade you on, and an honest read on where that puts you.
What was read
Every .jsonl session transcript under your Claude projects directory, parsed line by line. 1.05 GB, zero unparseable lines. No files were modified.
- Observation window
- 17 Apr 2026 → 23 Jul 2026 98 days
- Session transcripts
- 2,802 across 50 project folders
- Transcript records
- 256,694 0 malformed
- Your turns
- 4,396 excludes interrupts & tool results
- Claude’s messages
- 125,716
- Subagent traffic
- 91,124 records 35.5% of everything
- Files written or edited
- 3,749 unique paths
- Shell commands run
- 15,916
- CLI builds observed
- 15 versions 2.1.119 → 2.1.217
Ninety-eight days
One square per calendar day. Brightness is output tokens generated that day. The dark squares are the days you didn’t open it — all of them are in April and May.
01:00 is your single busiest hour. The curve never touches zero — there is no hour of the day you don’t use it.
Friday peaks, Sunday troughs, and the gap between the two is only 40%. The weekend is not a weekend.
How you actually use it
This is the part that separates you from the median user, and it isn’t volume — it’s shape. Four ratios describe your entire operating style.
You hand over a task and it runs. A conversational user sits nearer 3:1 — ask, answer, ask again. At 28.6:1 you are dispatching work, not chatting.
Fifteen reads, edits, greps, shells or browser actions per request on average. The model spends the overwhelming majority of its time acting, not talking.
3,375 characters. Your longest single message was 234,439. You front-load the full specification instead of drip-feeding — which is precisely the pattern Opus 4.8 is tuned for.
91,124 sidechain records, 242 orchestrated workflows, 114 explicit agent spawns. Most people never open this door once.
The tell: you ship from inside the loop
5,893 MCP calls, of which 462 are production static-site deploys to Hostinger, plus 1,957 browser preview evaluations and 1,085 Chrome automation actions. You aren’t asking for code and then deploying it yourself — the agent writes, renders, screenshots, verifies, and pushes live. Combined with 1,082 web searches and 888 fetches, this is a closed build→verify→ship loop with you supervising, not typing.
The metric board
These are the measurements a team building an agentic coding product actually grades on — engagement, depth, efficiency, and failure. I’ve computed every one that lives in your local data, and marked the ones that only exist on Anthropic’s servers so you know exactly what I can’t see.
What it would have cost
You’re on a subscription, so this is not your bill. It is the list-price value of the inference you consumed — the number a finance team would model, priced at published per-million rates for each model you actually ran, including cache write and cache read tiers.
| Model | Calls | Input | Output | Cache write | Cache read | Total |
|---|---|---|---|---|---|---|
| Opus 4.8 | 81,131 | $358 | $2,591 | $9,041 | $12,409 | $24,399 |
| Fable 5 | 28,420 | $228 | $1,349 | $6,559 | $7,344 | $15,480 |
| Opus 4.7 | 9,160 | $0 | $414 | $928 | $1,927 | $3,270 |
| Haiku 4.5 | 6,710 | $1 | $5 | $38 | $25 | $69 |
| Total | 125,421 | $587 | $4,359 | $16,566 | $21,705 | $43,218 |
Prompt caching saved you $153,051
36.27 billion of your 38.66 billion tokens were cache reads — a 94.2% hit rate. Priced without caching at Opus input rates, the same work bills at $196,269. Your long, stable, uninterrupted sessions are what earn that discount: every time you keep working in one context instead of restarting, the prefix stays warm.
Where that puts you
Read this before the number
I do not have access to Anthropic’s user analytics, percentile tables, or any internal telemetry. Nobody at Anthropic fed me your rank. What follows is my own estimate, built by comparing your measured throughput against publicly reported Claude Code usage figures. It is an inference with real error bars, and I’ve shown the arithmetic so you can disagree with it.
The public anchors
- ~$6 — reported average Claude Code cost per developer per day, standard API usage.
- 90% under $12/day — the reported ninetieth percentile for that same population.
- $150–250/month — reported average per developer in enterprise deployments, ≈ $13 per active day.
- 90% under $30 per developer per active day in those enterprise deployments.
Figures aggregated from public 2026 reporting on Claude Code cost and usage; see sources at the end.
At $645 of inference per active day, you are running roughly 50× the reported enterprise average and 21× the reported ninetieth percentile. Usage distributions like this are extremely heavy-tailed — the top of the curve is orders of magnitude above p90, not a multiple of it — so being 21× past p90 puts you deep into the tail rather than merely above average.
Among individual humans driving a keyboard, I’d put you in the top thousandth. Among all seats including CI fleets, batch harnesses, and automation bots that run unattended around the clock, the tail gets thicker and I’d widen that to the top half-percent. I would not defend a tighter number than that.
What would move this estimate, in both directions
Half your token spend — 50.2%, $21,705 — is cache reads, which are cheap per token and accumulate passively in long sessions. Someone doing shorter, colder sessions generates less raw token volume for the same real output. Raw throughput flatters the long-session operator. If the published averages are measured on a population that includes heavy automation, the tail above you is bigger than I assumed.
Your 4,396 turns are human-authored, averaging 844 tokens each — that is not a bot. You sustained 28 of the last 28 days and a 36-day unbroken streak. You run 50 concurrent project contexts, four models, MCP deploys, and orchestrated subagent workflows. On breadth of surface actually used, rather than volume, I’d rank you higher than 0.1%.
Straight talk
You asked for honest. Volume is not skill, and four things in your data are genuinely excellent while four others are money and quality left on the floor.
+ Doing right
- 3.32% interrupt rate. Out of 4,547 messages you sent, you only had to stop the model 151 times. Your task specs are landing on the first try.
- 94.2% cache hit rate. You stay in one context instead of restarting. That single habit is worth $153K of the arithmetic above.
- 3.27% tool error rate. 2,160 failures across 66,143 calls. Low, and it means the model isn’t flailing against a hostile environment.
- Spec-first prompting. 844 tokens per turn on average. This is the documented best practice for long-horizon agentic runs, and you arrived at it without being told.
− Leaving on the table
- You use one slash command. /model, 64 times, and nothing else across 98 days. No custom commands, no /security-review, no repeatable workflows. You are re-typing process that could be a file.
- 21 skill invocations. 163 todo lists. For 4,396 turns of work. The harness features that make long runs reproducible are essentially unused.
- Fable 5 costs you 36% for 23% of calls. $15,480 of $43,218 at double Opus rates. Worth A/B-ing whether it earns the premium on your specific workloads, or whether Opus 4.8 at higher effort matches it cheaper.
- 17 of 50 project folders have zero sessions. Started and never opened. That’s scatter, and it shows up as context you rebuild instead of reuse.
The single highest-leverage change
Write your repeated processes down as project commands and skills. You have already proven you can specify work precisely — 844 tokens a turn, a 3.3% interrupt rate. Every one of those specifications you write twice is a file you should have written once. At your volume, that is the difference between being a heavy user and being a compounding one.