# tsc-rs: An AI Built a Rust TypeScript Compiler for $24K — Nobody Read the Code

> Source: <https://byteiota.com/tsc-rs-an-ai-built-a-rust-typescript-compiler-for-24k-nobody-read-the-code/>
> Published: 2026-10-16 09:07:28+00:00

Theo Browne spent five months and $420,000 in AI tokens trying to port the TypeScript compiler to Rust. The models stalled at 84% compatibility and refused to go further. He switched to Claude Opus 5.5, changed strategy, and finished in two weeks for $24,047. The result — **tsc-rs** — passes 181,711 tests and runs 11.4x faster than TypeScript 6. Theo has never read a single line of the 1.3 million lines of Rust it produced.

## What tsc-rs Is

tsc-rs is a Rust port of Microsoft’s Go-based [TypeScript 7 compiler](https://byteiota.com/typescript-7-go-compiler-breaking-changes-migration-guide/), including the type checker and language server. Released October 7 by Ping Labs, it installs via npm (`npx tsc-rs -p tsconfig.json`) and runs on Linux x64 and macOS arm64. It is version 0.1.0 and explicitly experimental.

This is not a port of the original TypeScript compiler. It’s a port of the Go rewrite that Microsoft shipped earlier this year. Agents translated Go to Rust, preserving the algorithms and structure — a very different job from starting with TypeScript and JavaScript.

## The Real Performance Picture

The headline number floating around is 12.5x faster than TypeScript 6. That’s accurate for one specific benchmark — T3 Code with the Effect plugin enabled. Across six real-world projects, the honest average is **1.61x faster than tsc 7** and **11.4x faster than tsc 6**.

| Project | tsc 6 | tsc 7 (Go) | tsc-rs (Rust) | 
|---|---|---|---|
| VS Code (3.75M lines) | 54.56s | 6.84s | 4.20s | 
| Sentry (2.11M lines) | 58.76s | 7.90s | 4.46s | 
| Playwright (585k lines) | 4.48s | 0.66s | 0.34s | 

One caveat worth flagging: bun check is faster still — about 20.9x over tsc 6 — but reports diagnostic discrepancies on some projects. tsc-rs claims identical diagnostics to the Go compiler on TanStack Query and Hono.

## Why Claude Succeeded Where GPT Did Not

The obvious answer is model capability, but that’s only part of the story. The more important variable was task design.

The failed attempts tried to translate TypeScript to Rust directly. Claude Opus 5.5 translated *Go to Rust* instead — using Microsoft’s Go implementation as the reference. That gave the agent a structural map to follow and a verified implementation to mirror, rather than inferring intent from JavaScript types.

The second ingredient was the test oracle: 181,711 tests ported from Microsoft’s Go compiler. AI agents generate code, run tests, fix failures, repeat. When you have 181,711 automated checkpoints, agents can iterate quickly and verifiably. This is why compiler ports are unusually well-suited to agentic work — they have executable specifications, reference implementations, and massive test coverage. Most software projects do not.

## The Problem Nobody Wants to Talk About

1.3 million lines of Rust. 5,961 commits. Nobody has read them.

Theo put it plainly in the [announcement](https://x.com/theo/status/2107789940482621795): “I’ve never read a line of this code.” On [Hacker News](https://news.ycombinator.com/item?id=49994958), commenters called this “review debt” — a new category of technical debt where the burden is not messy code you wrote, but sound-but-unreviewed code an AI generated. The codebase is functional and passes tests, but no human understands why any particular line exists.

Browne added a “Slop Line” to the README — a clear demarcation between human-written and AI-generated content — which the community praised as genuinely useful transparency. It does not solve maintainability, but it’s honest. The maintenance question is real: TypeScript releases major versions roughly every six months. Keeping tsc-rs synchronized requires re-running Claude each time.

## What You Should Do

tsc-rs is not a drop-in replacement for tsc 7. Here’s the practical picture:

- **No Windows support.** Linux x64 and macOS arm64 only.
- **Known issues at 0.1.0:** monorepo conflicts, project reference bugs, LSP memory growth (~20 MiB per 1,000 edits).
- **Pinned to TypeScript 7.1.0-dev.** Not tracking stable releases yet.

The recommended path right now: run it as a shadow check in CI alongside tsc 7 — non-blocking, for diagnostic comparison. Do not remove tsc 7 from your gate. [The Register’s analysis](https://www.theregister.com/devops/2026/10/15/24000-ai-experiment-ports-typescript-compiler-to-rust/) agrees. Watch for version alignment and whether Ping Labs maintains it past 0.1.0.

The WebAssembly build is the genuinely interesting long-term play. If tsc-rs matures, embedding TypeScript checking in V8 without a VM becomes viable — a meaningful unlock for agentic tooling. That’s why it exists.

## What This Signals

The $420K versus $24K story gets attention because the numbers are dramatic. But the real signal is narrower: AI agents are viable for porting work when the task has automated verification at scale. Compiler ports have that. Most software does not.

A TypeScript team member noted on Hacker News: “honestly crazy that 3 of these ports have popped up in the last week.” They were not surprised by the quality. They were surprised by the volume. That’s the part worth paying attention to.