Theo Ported TypeScript to Rust with AI and Never Read the Code

Theo Browne published a Rust rewrite of the TypeScript compiler and admitted, in the README, that he has never read a line of the code. His own words: I've never read a line of this code.

That sentence is doing a lot of work. Some people found it funny. Some found it terrifying.

Most found it both.

So did the number next to it. The port cost over $420,000 in API tokens. Then he says you could probably have done it for $20k.

That gap is the whole story.

what ts-rust actually is

Here's a question people always ask: another TypeScript compiler?

Not quite. ts-rust (also called tsc-rs) is a full port of Microsoft's TypeScript compiler, type checker and language server into Rust.

It keeps the same command line, the same LSP, the same API. You install it with npm install -D tsc-rs and run it like tsc.

The twist is who built it. Not Microsoft. Theo, doing a bit and then not stopping.

And the results are real. On VS Code, a full type check runs in 4.20s against tsc 6's 54.56s. That is a 13x speedup.

On 181,711 ported Go tests, they all pass. Type checking lands at about half of the Go compiler's time across 60 projects.

a working v0 in 10 hours, after months of failure.

That is the part nobody expected.

the $400k mistake

What actually happens when you throw agents at a big port is not what the demos show.

Theo spent about $400,000 in tokens over five months using OpenAI models, burning through /goal loops. They wrote over 1.3 million lines of Rust and never got past roughly 84% compatibility.

Then he tried Opus. It had a working v0 in 10 hours.

He assumed it had reused the previous code. It hadn't. The new model looked at 1.3 million lines from the old agents and decided they were unrecoverable, wrote a brand-new crate from scratch in 10 hours, and left the dead code sitting in the repo untouched.

One model's six months of work was another model's garbage.

The final spend was about $24,000 over two weeks. He calls the old stuff "the slop line" in the README, and marks everything below it as written by his LLMs, not him.

I keep re-reading that part. He shipped it, benchmarked it, and then drew a line under his own authorship.

The cost math is the other thing. $400,000 for an 84% compiler.

$24,000 for a working one. Nobody modeling agent economics predicted that shape, where the expensive attempt is the one that fails and the cheap one lands.

bun check walked in the door

Most tutorials tell you to compare ts-rust against tsc. The real fight showed up from the side.

Just as the project landed, the Bun team announced bun check, a native TypeScript type checker built into the runtime, also written in Rust.

It is fast. On T3 Code, without Effect diagnostics, bun check finishes in 4.07s against tsc-rs's 7.25s.

But the interesting number is elsewhere. On VS Code, bun check runs a full check in 1.62s.

That is 33.7x faster than tsc 6, on a 3.75 million line codebase. The bar is not "faster than tsc." The bar is now "multiples faster than the Rust rewrite you just spent $24k building."

Theo did not fight it. He said bun check is likely the better choice for most apps, and noted tsc-rs is tuned to win on heavy functional types, the Effect-style code. Then he joked that he should drop ts-rust.

That honesty is rare, and it still stings to read.

I would have argued for burying the comparison. He published the number where a competitor beat him and told everyone to use the competitor instead. My instinct would have been worse than his judgment.

There is a smaller detail worth sitting with. tsc-rs wins when the Effect diagnostics run in the same pass, because bun check does not carry them.

So the honest framing is a narrow win on one kind of codebase, not a general one. He said that part out loud too.

why not rust, why not go

This is the context most hot takes skip. Two years ago, everyone asked why Microsoft did not port TypeScript to Rust.

Microsoft ported it to Go instead, as TypeScript 7. The lead dev explained it plainly: Go's memory model maps cleanly onto the original TypeScript codebase. A Rust port would have needed a ground-up redesign, not a port.

So there are now three positions. tsc 6, the slow original. tsc 7, the Go one Microsoft shipped.

And tsc-rs, the Rust one an LLM wrote in two weeks.

bun check wins clean unless you need Effect diagnostics. With those, tsc-rs gets them all in one pass and the field shuffles.

the reviewing problem

I used to think agent-written code was a tooling story. It is a trust story.

A big chunk of the reaction was not about speed. It was about whether anyone can review this.

The Bun project fought the same war when Zig's creator called its Rust rewrite unreviewed slop. Same criticism, different week.

Theo's answer was to put the warning at the top of the README: this is an early release, not a full replacement, and he has not read the code. That is more honest than most teams manage.

It also means the burden lands on you. If you run tsc-rs on your repo, you are the reviewer now.

---

the honest part

Most projects should not switch today.

If your type checks are slow and you just want them fast, use bun check or tsc 7. They are supported, they are fast, and nobody has to trust a stranger's unread Rust.

tsc-rs is worth watching if you run an Effect-heavy codebase, or you want a WASM-capable checker, or you simply find the experiment fascinating. It is not worth putting in CI next to your deploy step yet.

The biggest misconception is that this is a language debate. It isn't. The Go vs Rust choice was settled by how the codebase could be ported, not by which language is nicer.

And the quieter one: an agent writing a compiler does not mean the compiler is wrong. It means you cannot take its correctness on vibes. The tests pass, which is exactly why the caution is about review and not about speed.

what i keep coming back to

The $420,000 that produced almost nothing, and the $24,000 that produced everything.

If I had watched six months of agents get to 84% and quit, I would have concluded that LLMs cannot do this.

Theo tried one more model and it did. The lesson is not that agents are magic. It is that the same task can be impossible and then trivial depending on which one you point at it.

I have not read the code either. I am not sure anyone has.

Maybe that is the future. Someone writes the spec, an agent writes the compiler, and the rest of us decide whether passing tests are enough.