Theo’s Rust TypeScript Port Targets Cheaper Agent Compute

Executive Summary

A coding agent’s execution environment may become a meaningful cost constraint even as model inference gets cheaper. Theo’s agent-assisted Rust port of the TypeScript compiler makes that possibility concrete: his more interesting goal is fitting compilation, type checking, and an app-development loop inside a lightweight JavaScript execution environment, rather than provisioning a full machine for every agent.

His demonstration is substantial, but its headline needs unpacking. The “$420k” combines earlier unsuccessful experiments with a successful phase valued at full API prices—not an equivalent cash bill. And the successful port builds on Microsoft’s existing Go implementation. This is evidence of agents extending difficult engineering work, not evidence that the original engineering was unnecessary.

What Was Actually Built

In “You can rewrite TypeScript in Rust for $420k”, Theo announces a Rust compiler, type checker, and language-server implementation. He describes roughly five months of experimentation, followed by a successful Opus-driven effort over about two weeks.

The starting point matters. Rather than translating the original JavaScript implementation directly into idiomatic Rust, the agents faithfully ported Microsoft’s Go version, even recreating parts of Go’s standard library and runtime behavior. Theo says the initial result was two to three times slower than Go. He then directed the agents to keep optimizing toward a minimum twofold speedup.

He reports roughly twice the Go version’s speed on selected real projects, with larger improvements against the older JavaScript compiler. Those are creator-reported comparisons, not independently validated benchmarks. Integration of Effect-specific checking also changes some comparisons: a tool doing extra checking is not interchangeable with one measured without it.

Compatibility is similarly a claim to evaluate, not a settled certification. Theo points to issues that reproduce bugs in the targeted upstream version as evidence of faithful behavior. That is useful supporting evidence, but a small issue count cannot establish complete equivalence across TypeScript’s edge cases.

The Cost Headline Hides Three Different Numbers

Theo’s opening tally assigns approximately $400,000 of tokens to unsuccessful Codex experiments and $20,000 to the successful Opus effort. Later, his more detailed estimate puts the successful phase at roughly $24,000 at full API prices.

His subscription accounting is different again: he estimates roughly ten weekly account allowances of usage, spread across six accounts, translating to about $500 of allocated subscription usage, with a quota reset contributing. Neither figure is a universal price for reproducing the project. Subscription access, elapsed time, hardware, prior experiments, and human supervision remain separate considerations.

The editorially important distinction is between nominal inference value, allocated subscription cost, and total project cost. Treating them as one number would make this account misleading in either direction: neither “a $420,000 rewrite” nor “TypeScript rewritten for $500” adequately describes the experiment.

Why the Rust Port Matters Beyond Speed

The deeper motivation is WebAssembly and V8. Theo combines the Rust tooling with an in-memory shell and filesystem environment to demonstrate an agent building and running an app without relying on ordinary filesystem writes for the development loop.

He reports under 260 MB of RAM and a peak around 4% CPU for the demonstration. These figures describe the execution environment—not the hardware serving model inference. The demo runs through Node; deployment in a Cloudflare Worker remains a proposed next step, not an established production result.

The hypothesis is compelling: if inexpensive inference enables many concurrent coding tasks, provisioning a heavyweight environment for each could undermine the savings. A smaller development environment could reduce that overhead. This example shows feasibility for one workflow, not a general replacement for arbitrary native tools or full-machine testing.

The Bigger Story

Yesterday’s distinction between delegating implementation and delegating judgment still holds. Theo says he did not read the code, but his account includes continual audits, memory and operating-system fixes, additional machines, parallel-work coordination, and clearer completion targets. “No code reading” does not mean “no engineering work.”

The port strengthens the case that agents can execute ambitious, testable transformations when the starting artifact and environment are favorable. It also leaves maintenance unresolved: Theo himself expresses greater confidence in Bun’s ongoing maintenance for many users. Generating a working tool and sustaining a dependable toolchain remain different achievements.

Further Reading

• Theo’s full demonstration: worth preserving for the Go-to-Rust provenance, detailed cost qualifications, and lightweight development-environment demo—not just the headline speedup.