$400K in Tokens Burned, Zero Lines Read: AI Ported the TypeScript Compiler to Rust in Two Weeks

A Repository You Can Hardly Believe

On October 7, 2026, Theo Browne — t3dotgg, creator of the T3 Stack — published a new repository on GitHub: pingdotgg/ts-rust, also known as tsc-rs. What it does takes one sentence to describe: using LLMs, he ported Microsoft's TypeScript 7 compiler almost entirely to Rust — compiler, type checker, language server, nothing left behind. Note the foundation here: TypeScript 7 itself is the version Microsoft rewrote from JavaScript into Go. Theo effectively stood on top of Microsoft's rewrite and had AI do another cross-language port.

The README's opening line has already traveled the whole internet: "I wanted to see if LLMs could port the TypeScript compiler, checker and lsp to Rust. Turns out they can."

The next line hit even harder: "I've never read a line of this code."

A person who has never read a single line of the code just shipped a TypeScript compiler. That sentence is either a joke or the most honest — and most frightening — manifesto of the vibe coding era. Hold your verdict until you've seen the numbers.

The Numbers: 181,711 Tests and a 13x Speedup

The ts-rust README ships with a set of benchmark numbers worth reading one by one:

• 181,711 tests ported over from the Go version (about 181K) — all passing;
• type-checking across 60 open-source projects takes roughly half the time of the Go version (geometric mean);
• full type-check of the VS Code codebase (3.75 million lines): tsc-rs did it in 4.20 seconds. On the same benchmark, Microsoft's official Go-based tsc 7 took 6.84 seconds, while the previous generation tsc 6 (Node.js) was 13.0x slower;
• across 6 real-world apps, the geometric mean speedup over tsc 6 is 11.4x.

The npm package is simply called tsc-rs and is already installable. On performance, the Rust build genuinely leaves the Go build behind — and that is the hardest part of the whole story: this isn't a demo, it's a real compiler that runs faster with a fully green test suite.

But hold the hype for a moment. A few of these numbers deserve a discount, and we'll get to that in the opinion section.

First Burn $400K, Then Get It Done in Two Weeks

The most interesting part of this story isn't the technology. It's the bill.

Theo started with OpenAI's models — GPT-5.6 Sol and GPT 6 Astra. He had Codex run /goal loops for "months," burning through more than $400,000 worth of tokens at API pricing and producing 1.3 million lines of Rust. Then it stalled: compatibility stuck at 84% and wouldn't budge.

1.3 million lines of code, $400K, months of work, 84%. That's what you get when you try to brute-force a hardcore porting task.

Then he switched models: Claude Opus 5.5. Ten hours later he had a working v0. Opus didn't reuse a single line of what Codex had written — it started from scratch. Two weeks, done. At API pricing, the total came to about $24,047.

The twist isn't over. Because Theo was on Claude's subscription plan (the $200/month tier), what he actually paid out of pocket was roughly two and a half months of subscription — around $500.

His own summary, roughly: I burned $400K of Codex tokens and got nothing; I burned $20K of Opus tokens and got it done in two weeks.

$400K vs $20K vs $500. Three numbers side by side — the most gut-punching comparison in AI programming circles in 2026: what decides success isn't how many tokens you burn, it's which model you pick.

One more detail worth savoring: Theo describes his own role with the words "managing a team." He doesn't write code. His job is clearing obstacles, fixing failure modes, and opening up parallelism — paving the road for agents, running a fleet of them in parallel, acting as the unblocker himself. That's basically the standard posture of vibe coding at scale: the human retreats to management, and the code goes to "the team."

Why "Porting" Is an Agent's Comfort Zone

A lot of people saw this story and thought: if AI can write even the TypeScript compiler, are programmers done for? Not so fast. This task has a very special property that makes it ideal for agents: a perfect, automated referee — tests.

Porting and writing new features from scratch are two completely different tasks. When writing features from zero, an agent's biggest enemy is fuzzy requirements: you don't know what "done" looks like. Porting is different: the Go version of TypeScript already had 181K tests, each one a precise definition of what "correct" means. Every stretch of Rust the agent writes gets run against the suite — wrong, fix it; right, move on. It's a task with a built-in oracle.

That's the fundamental reason Theo's pipeline worked: tests are truth. The agent doesn't need to truly understand the mathematics of the type system; it just needs to turn tests green. 181K tests means 181K automatic acceptance checks.

Flip it around and it also explains why Codex's 1.3 million lines stalled at 84%. As the corners the tests don't cover pile up, what remains is the hard core that demands genuine semantic understanding — and the "turn tests green" loop breaks down there, because no test can tell you whether you're green. Opus's victory wasn't so much about being "smarter" as about its semantic understanding just barely clearing that bar under the same refereed conditions.

One line for vibe developers: picking the task matters more than picking the model. Tasks with a complete test suite and crisp acceptance criteria — ports, refactors, adding tests, fixing bugs — are an agent's comfort zone. Tasks with fuzzy requirements where acceptance runs on "vibes" will wreck even the strongest model. ts-rust isn't proof that "AI can write everything"; it's proof that "AI is strong on a refereed field."

"I've Never Read a Line": Capability Proof and Trust Problem

Back to the line that broke the internet: "I've never read a line of this code."

It reads two ways. The first reading is a capability proof: one person, without reading a line of code, directed AI to build a TypeScript compiler faster than the official Go version, with 181K tests green. That's vibe coding's moon landing — proof that under the right conditions, "not reading the code" is no longer a joke but a viable way to produce software.

The second reading is a trust problem: if the author himself hasn't read the code, would you run tsc-rs in your repository? A compiler sits at the very bottom of the trust chain: it reads all of your code and decides what your program means. A compiler nobody has read means the entire chain rests on four words: "all tests passing."

The dev.to analyses (two pieces, October 8 and 9) put it bluntly: the project declaring itself an early release rather than a full replacement is honest; but if you run tsc-rs in your repo, the reviewer is you — the author has told you plainly he hasn't read it.

That's not a dismissal of the project. Quite the opposite: Theo putting the warnings on the first screen of the README is a rare kind of honesty. The truly dangerous thing isn't "didn't read the code but told you" — it's "didn't read the code but pretends otherwise." In the vibe coding era, authorship and responsibility are splitting apart: the author is AI, the responsible party is you. ts-rust just laid that relationship out on the table.

There's an old pattern in tooling history: when each generation of automation first appears, people argue about whether "it can"; once it matures, they argue about whether "it's trustworthy." ts-rust ended the "can it" debate overnight and put the "can we trust it" question in front of everyone. That is precisely its greatest value: not a finish line, but an opening act.

The $500 Bill, Accounted Honestly

Back to the most eye-catching number: $500.

Honesty requires saying it plainly: $500 is a subscription-equivalent price, not the real cost. At API pricing, Opus burned $24,047 in those two weeks; add the $400K Codex burned earlier and the project's "true" token cost exceeds $420K. Subscriptions just spread the cost across all subscribers — Anthropic is covering the gap between $24,047 and the sticker price for you (and Codex's $400K was OpenAI's bill, counted separately).

The performance numbers deserve the same discount. Headline figures like 13.0x and 11.4x come with specific benchmark conditions — the diagnostics, for example, were measured on particular projects like T3 Code + Effect. Switch codebases and the numbers move. The README's data is real, but "real" is not "universal."

This isn't nitpicking. On the contrary — precisely because this project matters, its numbers deserve a microscope. Vibe coding circles have a bad habit: the prettiest number becomes the headline while the caveats hide in a footnote. Theo actually did fine here (the README states the benchmark conditions clearly), but the chain of reposts automatically drops the caveats. As readers and reposters, we owe it to say the discounted part out loud.

One line: applaud the conclusion that "model selection matters more than token spend," but don't treat $500 as the real ticket price for replicating this project.

Four Practical Takeaways for Vibe Developers

Setting the spectacle aside, this project offers four lessons you can take straight to your daily AI-assisted coding:

First: when you're stuck, switch models before adding tokens. 84% compatibility, 1.3 million lines, months of effort — the classic "pushing hard in the wrong direction." Ten hours after Theo switched models, v0 was running. The working rule: if a task has burned 3x your expected effort without passing acceptance, stop and switch models (or switch approaches) instead of doubling down. Sunk cost is the most expensive token in vibe coding.

Second: parallelism is a free accelerator. Theo's way of working was "open up parallelism": multiple agents running at once, himself as the unblocker. Most people still use agents serially — waiting for one to finish before starting the next. The working rule: split the task into non-blocking chunks (a port split by module, say), run them concurrently, and own the merging and conflict-fixing yourself. Your time costs more than tokens.

Third: write the warnings before the README. Theo put "early release, not a full replacement" and "I've never read a line of this code" front and center. That's not weakness, it's professionalism. The working rule: for anything you build with AI, the first screen of the README should state plainly what the AI wrote, how far your review went, and which pitfalls you already know about. Honesty is the cheapest trust-building there is.

Fourth: give your agent a referee, not inspiration. The fundamental reason ts-rust worked is 181K tests. The working rule: before you start, ask yourself what the acceptance criteria are and whether they can be automated. If yes, build the tests or acceptance scripts first, then let the agent loose. On a task with no referee, the faster the agent runs, the more brutal the rework.

Back to the opening question: a person who never read a line of code shipped a compiler — joke or manifesto? My call: it's a manifesto, but one whose validity holds only "on a refereed field." Step off that field, and "I haven't read it" remains a sentence that takes courage — or luck. ts-rust's greatest contribution is showing us exactly where that boundary lies.

Sources

• GitHub: pingdotgg/ts-rust (published 2026-10-07), https://github.com/pingdotgg/ts-rust