Engineering brief
Unlimited Claude Usage: The Hidden Cost of Long-Running Agents
At a glance
Niche watch
- Relevance
- Practical value
- Radar
- Time horizon
- Later
- Warnings
- None
One developer kept Claude running for 4000 hours across seven accounts, rewriting TypeScript in Rust and building a game clone. The trick: verifiable rewards and endless compute.
Long-running agents are feasible but require massive budget and careful verification design.
Watch if you're planning to run a long-term autonomous agent project and want to see failure modes and cost realities.
Summary
The approach. Theo demonstrates how to keep a large language model (Claude) running autonomously for days or weeks by structuring tasks around a technique he calls "hill climbing." The core idea: define a clear, verifiable success metric—like passing a suite of unit tests or matching reference screenshots—and let the agent iterate until it qualifies. He applied this to rewrite TypeScript in Rust (TS Rust) and to clone the video game Skate from scratch.
Why it works. The method mirrors the reinforcement learning with verifiable rewards (RLVR) used in model training. By giving the agent a programmatic pass/fail signal, the model can self-correct without human intervention. For TS Rust, the verification was simple: compile real-world TypeScript projects and ensure identical outputs. For the game, he used a panel of LLMs to compare screenshots against the original.
The cost reality. Theo burned through seven Claude subscriptions and estimates the API cost for TS Rust at $38,000—though he only spent about $500 in subscription fees due to subsidized pricing. The game project cost nearly $5,000 in inference alone, consuming 12 billion tokens from just 25 prompts. The numbers are eye-watering but demonstrate what's possible with enough budget.
The compute bottleneck. Once the agent had a verification loop, the next bottleneck was compute. Builds for Rust took 17 minutes each, causing queues of 12+ hours. Theo solved this by adding more local machines, then moving to Blacksmith CI, and finally adopting Boat.dev for ephemeral VMs. This reduced gate time from 70 minutes to 6 minutes and enabled more code to land.
The tooling gap. Boat.dev emerged as a key enabler: easy spin-up of VMs, snapshotting, and concurrent runs. Theo argues that managing agent infrastructure is like managing engineers—set goals, unblock bottlenecks, provide resources. But the analogy has limits: agents can't approve budget increases, and the human must monitor costs.
The trade-off. This approach is not for most teams. It requires deep expertise, a tolerance for massive token waste, and a willingness to chase ever-deeper optimization loops (Theo ended up writing a faster Rust compiler, Lust). The video is a fascinating showcase of what's technically possible, but the practical takeaway is clearer: invest in verification design and scalable compute—not in burning subscriptions.
My take
I admire the engineering but this is not a repeatable pattern. Most teams should invest in verification loops, not in burning $200 subs. The real insight is that agents need clear success criteria and the right tools, just like engineers. But the 'manager' analogy is dangerous – you can't ask an agent to buy more subs. The hallucination risk in self-judging loops is understated. Focus on building a good scaffold, then let the agent run, but cap cost and time.
What to do with this
- Identify one repetitive engineering task and design a verifiable success criteria for an agent to run autonomously.
- Estimate the cost of running an agent for a week on that task – include compute and token costs – and compare to current manual
- Experiment with a simple hill-climbing loop: agent writes code, runs tests, iterates until all tests pass, then commit.
Watch the video
This video is blocked due to your privacy settings. To watch this video, please accept YouTube marketing cookies.
Related breakdowns
Harnesses Don't Matter Anymore: Focus on the Agentic Environment
Theo makes the case that harnesses are fading; the future is ADEs that let you swap harnesses like models. But the evidence is mostly opinion.
The real ROI of AI coding agents is workflow design, not model
Three markdown files encode agent workflows that automate code review, autonomous merging, and pre-merge handoff. Theo reports 27 of 32 PRs merged without…
Most features are prompts once you expose the data
A T3 Code maintainer argues most planned features should be prompts. His examples are concrete; the vendor bias is real.
Get TL;DW
Too Long; Didn't Watch.
A concise breakdowns of the AI and devtools videos that actually matter for engineering leaders.
Free. Weekly. No hype.
Video and thumbnails remain the property of their respective creators. tldw.news provides editorial analysis, commentary, and discovery links to original content.