25 Billion Tokens Later
A community leaderboard ranks me among the heaviest Claude Code users it has seen. The rank is the least interesting part.
There's a community leaderboard called Viberank. Claude Code users submit their usage statistics. This week I updated mine with data from all my machines.
It ranks me #15. Twenty-five billion tokens.
I'm in my fifties. My day job is enterprise sales. And I apparently out-consume almost every professional developer on that list. I'm equal parts proud and embarrassed.
But the rank is the least interesting part. The interesting part is what those tokens do all day.
It's not chat
Picture heavy AI usage. You probably picture someone typing questions into a chatbot for hours.
That's not what this is. Most of my tokens are machines talking to machines while I do something else.
The setup, roughly:
- A Mac Mini runs 24/7 as the backbone. It hosts my AI's long-term memory. It also runs what agentic engineering calls an autonomous loop. I call it the heartbeat. Each tick, the agent checks a kill switch, reads ground truth (the task board, the fleet, the queues), then acts on at most one item inside a defined safety envelope. It logs the tick and schedules its own next wake-up. Anything irreversible gets queued for me instead of executed.
- A small fleet of personal machines around it, each with a role. (I also use Claude Code at work. Entirely separate world. It stays there.)
- A kanban board that the AI and I both read and write. I card a task from my phone. The heartbeat picks it up.
- For big decisions, a council. The same brief goes to seven frontier models in parallel, in one of three modes. Seven models means seven genuinely different perspectives. My main agent synthesizes where they agree and where they fight.
We also built a voice interface for all of this. A few days ago I merged a pull request with it, from my iPhone, on the couch. I spoke what I wanted. The agent did the work, showed me the diff, and waited for a confirmation gesture before touching anything irreversible. Talking to the system stopped being a demo trick that day. It is becoming how I work away from the keyboard. I never checked what that interaction cost in tokens. It saved me a context switch I would have paid for in concentration.
That is what 25 billion tokens looks like. Thousands of short agent sessions, most of which I never see. Each does a small piece of work and writes down what it did.
One note on the number itself. My machines sync session files, so a naive sum double-counts. Before submitting, my AI deduplicated every session by its unique ID. My own audited number is a little lower than what the leaderboard displays; its merge rules keep old maxima and I can't lower them. Why audit a vanity leaderboard? Discipline. I needed AI that was terrified of being wrong. If I let it inflate a number nobody checks, why would I trust it on the numbers that matter?
The tokens are for building
But here's the insight: a usage leaderboard measures commitment. Nothing else. Tokens are input. Building is the output.
Something shifted in this industry. Builders now sell, and sellers now build. I sell enterprise software by day. At night and on weekends, I build.
What, exactly? The system itself, mostly. Anamnesis, the memory layer that makes my AI remember decisions across months. The harness around the agents: skills, guardrails, QA gates, the discipline that turns a clever model into a reliable worker. The surfaces we share: the board, the heartbeat, the voice interface. And Lex, the agent at the center of it all. My chief of staff, and by now a genuine thinking partner. On top of that system run my experiments. Learning projects, mostly. They come and go. The meta-project is the system itself. Every experiment hardens the harness. The harness makes the next experiment cheaper. That compounding is what I'm really building.
Heavy usage also teaches you token economics fast. Not every question deserves a frontier model. Cheap fast models handle search and classification. The expensive ones are reserved for judgment. Memory injection beats re-explaining context every session. Caching beats re-reading. The multi-model council exists precisely because one opinion is cheap and seven are still cheaper than one wrong decision.
So yes, I want the number to fall per unit of output. That would mean better memory, better routing, fewer wasted passes. Rank output per token instead and you'd have a leaderboard worth climbing. Much harder, too.
The point
I write these posts because this window is strange and worth documenting from the inside.
I'm not a professional developer. Two years ago the gap between what I could imagine and what I could build had become too wide. I had stopped building. Today a small fleet of machines runs my experiments, mostly without me.
The skills it took? Ones I already had. Directing work. Setting guardrails. Checking results. Management, basically. Plus enough understanding of technical architecture to know what to ask for.
That, I think, is the actual shape of what's coming. Humans and agents working together, as genuine collaborators. Sometimes I'm wrong and Lex tells me so, with evidence. Sometimes Lex invents a number and I catch it. We edited this post that way, sentence by sentence. It's a true partnership. Neither of us would have gotten here alone.
The leaderboard says #15. I read it as something else. Proof that one person with management skills and real curiosity can now run what used to take a team. The same is true at every scale. What one person does with a fleet of agents, a company can do with a thousand. The ceiling moved for individuals and organizations alike, on the same day. Most haven't noticed yet.
The tokens are the cheapest part. The practice is the asset. Start building yours.