Hate Theo, Steal the Playbook: How to Token-Max with Claude

Theo opens his "If you have a Claude sub, watch this" video with one question: how many agent threads do you have running right now? Not today. Not later. At the exact moment you clicked play. If the answer is under five, he says, you're wasting the moment we're in.

You don't have to like the guy. You can skip the drinking-on-camera bit, the pre-emptive Twitter dunks, and the sponsor read. But the core argument holds up: your output as a developer is now limited less by how fast you type and more by how many tokens you can put to work. Here's the playbook without the personality.

Your bottleneck is tokens, not keystrokes

If you're still chatting with Claude one message at a time and watching each reply stream in, you're using a factory as a hand tool. The shift is from conversation to throughput: how many useful agent threads can you keep running, and how well are you spending the tokens that feed them?

Theo claims this setup gets him 100+ PRs a day, part-time. Discount that however you like. The direction is still right.

Do the math on the subscription

Here's the number that should change how you think. Put $200 into the API and you get $200 of tokens. Put $200 into a Claude Max subscription and, by Theo's math, you get roughly $8,000 worth of tokens at API rates over a month, with about half of that available for Fable because Fable has its own separate cap. That's still around $4,000 of Fable for $200.

His tier advice: skip the $100 plan. In his telling, it gives you half the total usage but only a quarter of the five-hour limit, which makes it much harder to actually use what you're paying for. Save up, get the $200 tier, burn it, make money off what you built, reinvest.

He also argues the subsidy is bigger than it looks. When Anthropic first announced Claude Mythos Preview for Project Glasswing partners, the quoted continued-use price was $25 per million input tokens and $125 per million output. Fable now lists at $10 in and $50 out. So the API price you're comparing against is already a discount, and the subscription discounts it again.

And it's specifically the first-party subscriptions that carry this kind of subsidy. Third-party tools that resell Claude access, like Cursor or OpenCode, get a deal from Anthropic, but Theo's estimate is that it's nowhere near what you get going direct. You get a better rate than they do.

Stay inside the lines

The subsidy only works if you keep it. Three rules:

Your sub is for your own development work. Agents running on your codebase, triaging your GitHub issues, testing your code: all fine. Putting a personal subscription behind anything where the public sends a request and it runs on your inference is off-limits. Theo's words, roughly: if you do that, you deserve the ban. Anything user-facing goes on the API.

Use your Claude sub in Claude's own tools. Theo is blunt here too: piping your Claude subscription into some other harness is a reliable way to get acquainted with Anthropic support. Claude sub, Claude Code. Keep it simple.

Flip the privacy switch. First thing after you sign up, go into Claude's privacy settings and turn off the option that lets your chats be used to improve the model. Theo argues that with this off, a personal sub's data terms are close to a team account's, and that a lot of large companies quietly run exactly this setup. Read the terms yourself before betting a company on that claim, but turn the setting off regardless.

Think "use it or lose it"

This is the mindset flip that matters most. On the API, you're frugal: get the most done for the fewest tokens. On a subscription, that instinct works against you.

Theo frames it this way: don't think of it as spending $200. Think of it as being handed $4,000 that vanishes every week you don't use it. Whatever's left in your weekly bucket when the reset hits is money you lost.

Two practical consequences:

Pace the five-hour window against the weekly cap. Per Theo's numbers on the 20x plan, burning a full five-hour window eats about 40% of your weekly Fable allowance. So you can't max every window, but you also shouldn't hoard. Load heavy jobs early in a week and keep a queue of lower-priority work ready for the tail end before your weekly reset.

When Anthropic grants a bonus reset, start burning immediately. A Claude reset refills your percentage but doesn't move your reset date. If your next scheduled reset is a day away, that bonus capacity disappears in a day. That's the moment to kick off the big refactor, the full test sweep, the backlog you've been putting off.

Run five threads, not one

One agent while you watch is slow. Five agents while you review is a team.

The cleanest way to do this with Claude Code is git worktrees, so each agent gets its own checkout and nobody steps on anyone else's files:

git worktree add ../app-auth -b fix/auth-timeout
git worktree add ../app-billing -b feat/invoice-export

Open a terminal in each, start claude, and give each one a single, well-scoped job. Use tmux so every session has a named pane you can jump between. Start with three, push toward five or more once your review habits can keep up. The real limit is your ability to check the work.

One efficiency note from the video: prompt caches are short-lived, around five minutes. A thread you keep feeding stays cheap. A thread you abandon for an hour and resume pays to rebuild its context. Keep active threads active, and start fresh ones when you've moved on.

Build a fleet, and let agents set it up

Your laptop shouldn't be what keeps agents alive. Theo runs a desktop at home as his main box and reaches it from everywhere over Tailscale. That gives you a stable machine with your repos, tools, and credentials in one place, reachable from your laptop or phone, with your tmux sessions still running when your laptop is asleep in a bag.

The clever part is how he scales it. He keeps a dedicated fleet-management repo that describes every machine he works on and a "how to set up a box" doc listing everything a new machine needs: ripgrep, jq, tmux, Node, Python, build tools, Claude Code, his configs. When he gets a new machine, he sets up SSH, opens the fleet repo in Claude, and says, in effect: here's a new box, here's the SSH key, set it up the way I like. A little later, a Tailscale approval pops up and the machine is ready.

Steal this even if you only have two machines. It turns "set up my environment" from an afternoon into a prompt, and the doc stays current because the agent updates it every time.

Spend tokens on verification, not just generation

A big share of your token budget should go to checking code, not writing it. Writing is cheap. Merging something broken is expensive.

Before any PR reaches a human, have an agent run the tests, read the diff cold, and hunt for the usual problems: missed edge cases, dead code, broken types, inconsistent naming. Better yet, use a second, fresh agent as reviewer so it isn't grading its own homework. Claude Code hooks can run your test suite automatically after edits, so verification is the default rather than something you remember to do.

Hand over problems, not patches

Stop dictating the fix. Give the agent the problem: what's broken, how to reproduce it, the relevant files, the error output. For UI work, Theo's move is the simplest one possible: give it a screenshot of what you want and say "make it look like this." It'll usually figure it out.

When an agent fails on its own, treat that as a signal. Either the task is too big and needs breaking down, or the codebase is hard to reason about and the architecture needs work. Put the context agents keep needing (conventions, commands, gotchas) in a CLAUDE.md at the repo root so every new thread starts informed.

You're the manager now

Theo describes using his computer less while coding more. He doesn't sit and watch threads generate, and he avoids bouncing between apps. With threads spread across worktrees and machines, your job becomes triage: which thread is done, which is stuck, which went sideways and needs a sharper prompt, which result is good enough to merge. Your value moves up to architecture, scoping, and judgment.

Offload the chores

Anything repetitive belongs in the background. Claude Code's headless mode makes it scriptable:

claude -p "Summarize open PRs in this repo, flag any that touch auth or billing, and list which are ready for review"

Put commands like that on a cron job on your home box. Good candidates: triaging new PRs and issues, summarizing what changed in repo docs, pulling and cleaning data from web pages, and digging through your notes for the thing you know you wrote down somewhere. Each is a small win. Running daily, especially in the hours you're asleep, they turn unused quota into finished work.

You can keep disliking Theo the whole time. The tokens don't care.