Scaling Myself: Processing 26.8 Billion Tokens in 46 Days with Claude Code

For 46 straight days, I submerged myself in code, treating AI not as a glorified chatbot, but as the underlying operating system of my development workflow. Over this non-stop span, I used Claude Code to push my productivity to levels that would conventionally demand an entire engineering team.

Here is exactly what happens when you put Claude Code in the driver's seat, backed by the raw data of my daily workflow.

By the Numbers: 46 Days of Uninterrupted Coding

To understand the scale of this experiment, we have to look at the baseline metrics. Over 46 active days, my Claude Code integration processed an immense volume of data:

For context: 26.83 billion tokens equates to roughly 20 billion words. That is on the order of reading, re-reading, editing, and discussing five full English Wikipedias in just over six weeks. And this was driven by one developer alone, operating 39 projects in parallel.

Context Caching: The Secret to Massive AI Leverage

The raw number is impressive, but the composition of those tokens tells a much more interesting story. When sampling my raw transcripts, a distinct pattern emerges:

• Productive tokens (output + cache creation): ~570M tokens — this is what Claude creates anew for me.
• Leverage tokens (cache read): ~26.26B tokens — this is what I re-read from the prompt cache at every conversation turn.

In other words, for every 1 new token I generate, ~46 tokens of context are reused from the cache.

This caching ratio is exactly how my long sessions—spending hours submerged in a single codebase—stay economically viable. By utilizing the prompt cache, 90% of the context for every new message is served at 10% of the base price.

This ratio is also the silent tell of how I actually work: dense sessions with massive, persistent context, not 50 tiny isolated questions. I operate in an "open the repo, hold the context, solve three things together" mode, rather than treating the AI as a one-off chatbot.

Where the Tokens Went: Managing 39 Projects in Parallel

My three flagship projects concentrate ~57% of all tokens. This is not by accident. These are my largest codebases—a full mobile platform, the Activi.dev platform with 30+ live features, and a children's app with a heavy backend. Each project pulls massive amounts of context into every conversation turn.

On Activi.dev specifically, I logged 88,789 transcript lines across 185 sessions. This represents the highest work density in my sample, which tracks perfectly: it's the project where every feature I build is born, specified, implemented, and reviewed directly, without intermediaries.

Beyond these three, I keep 36 other projects in simultaneous rotation. These range from private financial stacks (Mercantil, Nexxera) to healthcare SaaS (Elosaúde), down to internal tooling and weekend experiments. I don't just use Claude Code on a project—I use it as the foundational layer for all my software development.

Working in Bursts: My Heaviest Development Days

Ten of my active days eclipsed 850 million tokens. My absolute peak hit on April 2nd, processing 2.73 billion tokens across 56 sessions—averaging a fresh session roughly every 25 minutes over a 24-hour window.

This reflects my specific developer profile: I don't work a traditional "9 to 5". I work in intense, focused bursts, diving deep into a project's context while the problem is still hot.

Model Selection: Picking the Right Tool for the Job

Claude Opus 4.6 is my undeniable workhorse, accounting for 83% of tagged sessions and 92% of total tokens. I only recently began folding Opus 4.7 into the mix. Sonnet typically shows up in my shorter, faster sessions, while Haiku plays the role of a lightweight subagent (handling ToolSearch and targeted reads).

My strategy is deliberate: I pick Opus for the heavy architectural lifting, keeping the smaller models strictly as specialized helpers. I don't use smaller models as a reflexive cost-cutting measure; I prioritize capability first.

Execution over Autocomplete: How I Used AI Tools

Translating these invocations into actual developer behavior:

• 28.8k Bash executions: I ran tests, applied database migrations, handled deployments, executed git commands, and read logs. I don't ask the AI "how do I migrate?"—I have it run the command, read the error, fix the code, and move on.
• 15.4k Edits + 4.3k Writes: This resulted in ~19.7k file modifications across 4,585 unique files. This isn't simple autocomplete; this is multi-file surgery in a single conversation turn.
• 15.7k Reads + 6.4k Greps + 845 Globs: Approximately 23k directed-read operations. My workflow relies on mapping the architecture thoroughly before making a single cut.
• 2k Agent calls: I heavily delegated to subagents (for codebase exploration, code reviews, and spec documentation). This is a functional multi-agent workflow, not a tech demo.
• ~3.5k Playwright operations: The AI actively clicked, navigated, evaluated, and took screenshots to visually verify UI changes, ensuring we didn't just stop at "it compiled, so it must be fine."

These numbers perfectly align with the core instruction I placed in my root CLAUDE.md file:

"For UI changes, start the dev server and use the feature in the browser before reporting it done."

I enforced that rule, and the AI followed it thousands of times.

Conclusion: AI as a Scope Multiplier

Looking back at the data, the conclusion is absolute: I do not use AI as a shortcut. I have turned AI into a scope multiplier.

• Massive Parallel Scope: I actively maintain 39 projects, covering B2B SaaS platforms, complex fintech systems, internal AI-augmented developer tools, and rapid experimental hacks. I am one human executing the roadmap of a conventional team.
• Extreme Context Density: Averaging 21M tokens per session with over 369,000 transcript lines proves my reliance on long, context-heavy iterations, rather than brief pings.
• 46x Caching Leverage: By staying inside the context window and iterating deeply, I extract maximum value from Claude Code.
• Process Discipline: The 3,192 TodoWrite and 2,004 Agent invocations prove I don't "wing it." I plan, delegate, track, and close.
• Relentless Consistency: 46 active days out of a 46-day window. Zero idle days. This isn't a temporary sprint; this is my new baseline pace.

The headline metrics—26.83 billion tokens, 1,272 sessions, 4,585 unique files, 39 projects—make for a spectacular tagline. But the reality underneath is far more valuable. It is the byproduct of a rigorously built system. I use dense sessions, strict model delegation, heavily mechanical tool usage, and most importantly, an approach that treats Claude Code as a senior pairing partner rather than a luxury Stack Overflow.

That is what 26.8 billion tokens can buy when you know exactly what you're doing.