TypeScript Compiler Rewritten in Rust by AI for $20K

After burning $400,000 of codeex tokens over five months with no success, Theo used $20,000 of Opus 5.5 to complete a full rewrite of the TypeScript compiler, type checker, and LSP in Rust within two weeks, though he did not read a single line of code during the process. He spent $400,000 on codeex tokens without success.

However, a subsequent attempt using $20,000 worth of Opus 5.5 tokens achieved the goal in just two weeks. Theo emphasized that he did not personally review any of the code written by the AI during this process.

Theo noted that while this level was impressive, the final 16% of the code proved significantly more challenging to complete.

Despite this difficulty plateau, the speaker successfully shipped the project by overcoming these limitations.

The process of converting TypeScript files into JavaScript is considered simple, with Theo describing it as "easy, borderline trivial." However, the more complex task is checking the TypeScript to ensure type validity and correct usage throughout an application.

This distinction leads to development workflows that often separate transpilation from type checking to improve overall build speeds. ESBuild, developed by Evan W. (formerly CTO of Figma), is an example of a tool designed for bundling efficiency.

The type system's ability to encode all JavaScript operations, including dynamic type changes and prototyping, contributes to this complexity.

This includes handling variable type changes and prototyping, which are inherent to JavaScript.

Rewriting this type checker in a non-JavaScript language inherently introduces challenges, as the "weirdness" of JavaScript must be explicitly managed as an external constraint, unlike when working within the same language context.

Go was chosen for its strong concurrency model and its syntactic similarities to JavaScript, making it a suitable candidate for the rewrite.

The Go implementation also offered better core utilization compared to the original TypeScript version, contributing to its enhanced performance.

Directly porting the original TypeScript code from JavaScript to Rust with AI models proved unviable, as demonstrated by the struggles of other models like 56 Soul and Astra.

Go, having a more refined structure, acted as a more effective intermediate language for the Rust port. Theo's agent-based migration strategy involved porting Go's standard library to Rust line-by-line.

This process highlights that certain intermediate languages can significantly streamline complex code migrations, making them more achievable for AI agents.

Initially, the AI-generated port was two to three times slower than the existing Go version.

Theo guided the AI to improve its performance by instructing it to achieve a 2x speedup, a task that ran for two weeks to reach the desired efficiency.

The primary motivation for rewriting TypeScript in Rust was not to achieve higher performance than the existing TypeScript Go version.

Instead, Theo undertook this project to rigorously test the boundaries and capabilities of large language models (LLMs) in handling complex architectural migrations.

The successful completion of the project demonstrated that these models are indeed capable of executing sophisticated code migrations effectively.

This means not only the developer's code but also the entire garbage collection system must be bundled.

This overhead from garbage collection results in larger file sizes and can lead to performance issues within WebAssembly environments. Consequently, it complicates the goal of achieving lightweight, efficient execution in web contexts.

The Rust port aims to circumvent these limitations and regain portability within browser and V8 environments, offering a more efficient alternative to Go's WebAssembly output.

The absence of a garbage collector in Rust makes it more suitable for environments requiring minimal overhead and fine-grained memory control, aligning with the objectives of WebAssembly deployment.

Current AI agent architectures, such as those provided by Cursor, often require full virtual machines (VMs) with substantial resources, like 32GB of RAM per thread.

These agents need environments resembling real Linux or Mac systems, complete with terminals and bash access, to execute commands and interact with codebases effectively. This demand for full operating system functionality distinguishes them from simpler sandboxed solutions.

The reliance on full VM isolation for each agent thread translates into significant computational costs, making traditional sandboxing or deeper virtualization increasingly resource-intensive rather than cheaper.

This approach allows for running code on-demand, which substantially reduces the costs associated with idle resources. By sharing the underlying Linux instance, Cloudflare avoids the overhead of managing separate VMs for each customer.

The shared execution layer enabled by V8 isolates allows Cloudflare to maintain profitability while offering competitive pricing compared to services like Vercel or Heroku.

Running code within a JavaScript isolate imposes significant restrictions, such as the inability to access the local file system. This is because the file system is not contained within the isolate itself.

Furthermore, JavaScript isolates typically cannot execute native binaries directly, as doing so would compromise the isolation and security boundaries.

These limitations, including the lack of persistent server capabilities, hinder the implementation of traditional development workflows within isolate environments, making them less suitable for tasks requiring broad system access.

These isolates facilitate communication between processes without mutual interference, providing a secure and performant environment.

The speaker argues that V8 isolates represent a superior abstraction for computation compared to traditional OS-level virtualization methods like Docker, offering better resource utilization and isolation.

While isolates are effective for deploying built code, their limitations in native kernel and file system access restrict their utility for complex build processes.

For example, Cloudflare workers provide sandboxes that operate differently from their worker hosting environments, reflecting these build-time constraints.

Theo managed to bridge this gap by creating a specialized environment where an AI agent could effectively "lie" to the system, thereby maintaining a functional state necessary for the build process.

He configured the agent to make the `cargo job` count configurable and to parallelize tasks, optimizing the build process. Managing compute constraints often involved SSHing into additional fleet machines to scale resources.

Critical to the project's success was auditing failure modes and adjusting the system to enable parallel execution effectively. Theo's role shifted from a coder to a manager, clearing blockers for the agents rather than writing code himself.

Previously, engineers would often conceive complex architectural ideas that remained theoretical due to the impracticality of testing them. AI now allows for immediate validation of such "insane ideas."

Theo successfully utilized Opus to verify whether his porting concept would run effectively on Cloudflare, transforming a speculative idea into a practical experiment.

This new capability suggests a paradigm shift where traditional engineering constraints on experimentation are significantly reduced, enabling rapid testing of innovative, high-risk projects.