The number, up front
100 million tokens. Six months. Eighteen active projects on the daily-driver shelf, plus a few in cold storage.
That's the headline. The Anthropic dashboard has the receipts.
This piece is the operator-tier read for anyone evaluating whether Claude Code is sustainable for serious work. The "is the tool good" question is already answered. The next one is worth ground covering. What does running this thing at scale actually look like. What does it cost. What does it buy.
What the tokens bought
A finite list of things you can actually point at:
- Solo publishing operation for a real-time strategy game. Discount calendar, marketing campaigns, creator outreach, social content, daily community management. One operator. Six months. (Case study: mechabellum.)
- A personal site rebuild. Schema markup, security headers, an entire portfolio re-architected from React 18 to Next.js 16. The site you're reading.
- A brain. Not metaphorical. A typed-wiki memory system that compiles into context every time I open Claude Code in any project. Knows who I am, who my family is, what I'm working on, who the stakeholders are at each client. Decisions get banked as append-only markdown nodes. The compile step rewrites the rendered context files from substrate. It's the thing that makes 18 projects tractable from one operator's keyboard.
- A recent applied-AI consulting engagement at a Southeast SMB. Eight stakeholder dossiers built from transcripts, an N-agent factory generating per-person briefs, a synthesis layer, and a rendered HTML site I can walk into a townhall with. Confidential, so I can't link out. But the substrate is the proof.
- Four or five smaller experiments that didn't ship. Token burn that produced nothing. The honest portfolio includes those.
If you're scanning this piece for the "wow look at this output" moment, that's the list. Each one took the kind of token volume most operators don't run.
The week that anchored the curve
There's a weekend in there worth naming.
I rebuilt the brain. Not the metaphorical one. The actual Orchestrator memory system. The typed-wiki compile, the auto-backlink graph, the schema lint, the per-node frontmatter contracts. Saturday morning, the system was a half-formed pile of markdown with inconsistent shapes. Sunday night, it was compiling 462 nodes, two rendered sections, seven auto-generated backlinks per relevant node. Early April.
That weekend burned through about 8 million tokens. One operator. One laptop. A wife who tolerates me working through the weekend more graciously than I deserve.
What I'd tell you about it if we were sitting next to each other: the token bill on that single weekend was probably $90. To get the equivalent work out of a contractor would have been a month of back-and-forth and a five-figure invoice. The economics aren't subtle. They're embarrassing.
How the workflow actually shapes up
At this volume, Claude Code stops being a tool you open when you need help. It becomes substrate. It runs underneath everything.
The shape is some version of this:
- A typed-wiki memory layer that compiles into context. Every session starts with the right backstory loaded.
- Per-project CLAUDE.md files documenting the local quirks, voice rules, deploy gotchas, banned moves.
- A factory pattern for any artifact that ships repeatedly. Substrate is markdown or JSON. Render is HTML or whatever. The substrate is hand-maintained. The render is regenerated, never hand-edited.
- Parallel agents for anything that can run in parallel. N stakeholder dossiers, one agent per stakeholder. N research threads, one agent per question.
- A daily session-wrap discipline that commits work, updates memory, drops breadcrumbs for the next session.
If you've heard people use the phrase "vibe coding," this is the opposite shape. The substrate is engineered, the agents read what's in it, and the output is reproducible because of that, not because the AI is doing magic.
What this honestly costs
Bill range across the last six months: somewhere between $500 and $1500 a month. Variance driven by how many multi-agent weekends I run.
For context. A junior consultant retainer in this town runs $4-8K a month. A senior contractor runs $12-20K. A SaaS subscription for a comparable workflow doesn't exist. There isn't a "Claude Code at scale" pre-built product to compare against. You're either building this kind of substrate yourself or you're not.
Less than I expected, honestly. The unit economics of letting a model do the boring half of a build are good enough that the optimization isn't "use less of this thing." The optimization is "use it on the work that wouldn't get done otherwise."
Where the tokens burn for nothing
Honest list. Not flattering.
Context drift. I burn tokens letting Claude re-read the same substrate every session because I haven't taught it which files to load. The fix is per-project CLAUDE.md hygiene, which I am still bad at across most of the 18 projects.
Substrate rot. Memory nodes go stale. A banked lesson from three months ago names a function that no longer exists. I trust the memory more than the current code state, and I get burned by it. The fix is verifying claims against live state before acting on memory.
The auto-memory-hook surprise. There's a Claude Code hook that reformats certain markdown frontmatter on write. If your project uses a typed-wiki schema that doesn't match the hook's expectation, it silently mangles your files. I have an entire concept node banked just for that gotcha. Discovering it cost me a Tuesday afternoon.
Token burn without artifact. Some sessions produce nothing shippable. I'd rather not show you those weeks. They exist in the curve. Anyone telling you their AI workflow is 100% productive is selling something.
Voice drift. This one's the worst, because the failure mode is invisible. A piece I draft in Claude's default voice reads fine to me on first pass. My wife reads it and points at the em dashes, the "moreover," the triple-beat lists. She edits Lauren-tone for a living. Without that editorial check, the substrate slowly turns into LLM mush.
Who this is for. And who it isn't.
The right reader for this shape:
- You run an operation. An actual ongoing operation with multiple parts moving in parallel, not just a one-off project.
- You've already gotten past the "wait, can it really do X" phase. You've shipped at least one thing with AI assistance.
- You're frustrated that the standard Claude / ChatGPT / Cursor workflows feel like a tool drawer instead of a workshop. You want the workflow to compound.
The wrong reader:
- You want a tutorial. There are better ones elsewhere. This isn't one of them.
- You want a vendor recommendation. I'm not pitching Claude Code over anything else. Use what fits.
- You're looking for "will AI replace my team." It won't, and the operators framing it that way are missing the move.
The starting-fresh shape
Build the substrate first. Before any agent, before any factory, before any clever orchestration. A typed-wiki memory layer with a compile step. Per-project CLAUDE.md files. The discipline of session-wrap commits.
Then add agents. Then add parallel patterns. Then layer the factory shapes on top.
The pattern is durable across projects. The agents are interchangeable. The substrate is what compounds.
That's the part I'd tell a peer who asked. Whether you burn 100M tokens in six months or 10M, the shape is the same...
If you want help building this kind of workflow inside your operation, the 4-day Discovery is how that conversation starts. If you want the deeper personal narrative about how I use Claude day-to-day, How I Use Claude is the longer read.