▶ YouTube Summaries

← All summaries
t3dotgg#▶ Watch

Hill climbing Claude for weeks: TS Rust, Lust and Skate 3 Bench

2026-10-28 Wed ⏱ 38 min t3dotgg

Theo Browne describes the extreme end of his agent usage: projects that run Claude for days or weeks from a single prompt, burn thousands of dollars of API-equivalent tokens, and consume seven Claude subscriptions. The examples are Skate 3 Bench (a skateboarding game built from scratch), TS Rust (TypeScript compiler rewritten in Rust) and Lust (a fast Rust compiler built to speed up TS Rust). The method is hill climbing: pick a tedious goal, give the agent an automatic way to check progress, supply the tools and compute it needs, and keep asking what blocks it. He states the video is not a recommendation to work this way.

Scope and examples

  • Opus 5.5 is described as a balance of capability, focus and price that made this style of work addictive.
  • Normal work (T3 Code, T3 OS) costs about $2-8 per prompt; these projects burn hundreds of dollars per prompt and run for weeks.
  • About 4,000 agent hours across projects, spread over seven Claude accounts.
  • TS Rust: TypeScript rewritten in Rust, 4-10x faster builds. Lust: a Rust compiler, drop-in for cargo for a subset of Rust, aiming at 100x faster builds.
  • The video is framed as a showcase and a complaint that these approaches work, not as practical advice.

Skate 3 Bench

  • Background: SkateBench (name the trick) was saturated and labs used the public questions as training data, so a private version exists.
  • Skate 3 Bench is a playable skate game and engine written entirely by Claude in the browser (three.js), with flick-it right-stick trick controls and a small park.
  • One thread ran 4 days with 25 prompts (mostly "continue" after machine reboots), over 12 billion tokens, roughly $5,000 at API prices.
  • The prompt used /goal with controls, physics, camera, trick list and Blender access; /goal is called a foot gun, but fine if hurt is the aim.
  • Verification loop: the agent screenshots its build in set states, compares them with real Skate footage, and a panel of LLM judges gives feedback.
  • Planned but skipped: record real controller inputs from the original game and replay them against the clone.
  • Quirks: about $800 spent on skybox tuning; the model brightened the game because Skate 3 was the reference, so the reference was switched to Skate 1.
  • A separate project rewrites Skate 3 line by line from a decompilation in Bevy; that is easy to hill climb, unlike inventing something new.

Hill climbing and verifiable rewards

  • Models have knowledge (pre-training) and behavior (reinforcement learning).
  • RLVR (reinforcement learning with verifiable rewards): models are trained against programmatic checks of success or failure, e.g. tic-tac-toe moves or code that turns file A into file B with given errors.
  • The closer a task resembles that training shape, the better the model performs.
  • TypeScript suits this: compile real projects with a pinned official compiler, insert random errors, and require the port to produce identical outputs.
  • For TS Rust the instruction was to chase identical output on real projects; the first working version was slower than TSGO, then the goal became 2x faster with all tests passing, and the agent kept going until it was.

Recipe

  • Step 0: have many Claude subscriptions to burn. API prices are not worth paying; a $200 plan gives roughly $12k of usage. TS Rust cost about $38,000 at API prices but at most around $800 in subscriptions.
  • Step 1: choose a goal that is as tedious as possible (e.g. rewriting a 100,000+ file codebase); agents do not mind tedium.
  • Step 2: find a verification that needs no human, ideally code returning pass or fail, at least something another agent can judge. TS Rust saw about 7,884 commits during the loops.
  • Step 3: give agents the tools they need (GPU, GUI, Blender, browsers, compute). Needs change over time, especially with parallelism.
  • Step 4: ask the agent what bottlenecks it. Steps 3 and 4 form a loop, and the loop leads back to more subscriptions and to new goals.
  • Managing agents is compared to managing people: the job is removing blockers, not checking every line.

Compute bottlenecks on TS Rust

  • Rust builds are slow (not because of the borrow checker), so agents queued for compute.
  • Asking a check-in thread what blocks progress led Claude to build a queue gating Rust runs, then to request more compute.
  • Eight local machines plus two VPSs reached over SSH helped; agents still waited up to 12 hours per run.
  • Moving builds to Blacksmith cut waiting to about 1.2 hours at a cost of over $2,000; Blacksmith is built for CI jobs, not agent SSH loops, and the regular CI bill was under $30.
  • Builds still took 20-40 minutes, which led to Lust.
  • Using one computer, about one to two subscriptions per week were consumed; with compute abstracted, all seven.

Boat (boat.dev) sandboxes

  • Boat spins up disposable VMs from a CLI (boat new, boat ssh, boat desktop for a Linux GUI, boat limits, stop by ID); no GPU.
  • Pricing is a subscription with limits on concurrent sandboxes and starts per minute, hour and day; Theo went from $20 to $100 to $500 and considers $2,000.
  • Snapshots allow building once and starting many copies, so sub-agents do not pull the whole repo and rebuild.
  • Before: four shared slots on a VPS, 40-70 minutes per gate, about 70 changes per day. After: about 6 minutes (353 s) per gate, nearly triple the landed code, and Claude burn rate rose fourfold (seven accounts instead of six).
  • Compute demand for agents is flexible, like desks for shifted workers: buying for peak wastes money or blocks agents. Theo invested in the company.

Lust

  • Built to unblock TS Rust; it required reinventing parts of Rust, Cargo and LLVM.
  • Goals set: builds and CI 100x faster than cargo, with binary performance within 20%.
  • Result so far: a build that took 17 minutes with Cargo runs in 12 seconds; output binaries differ from rustc's, so both correctness and performance are checked instead of identical output.
  • It barely works outside TS Rust.

Conclusions

  • Hill-climbable obstacles appear inside bigger projects; the loop produces new goals (the chain started from running TypeScript in a V8 isolate on Cloudflare and led to a Rust compiler and an OS).
  • Intelligence is said to get 4-5x cheaper per month, so loops like these become cheap within a year, apart from compute.
  • Software work shifts from engineering the solution to engineering the environment in which agents work.
  • Theo advises against working this way today (hellish, many holes found), yet calls it the most fun in his career and says existing tools, if not closed-source, are malleable.