Agent-Assisted Rust Rewrites Report Large Gains, While Most Figures Are Self-Reported, Baselines Are Questioned and Verification Is a Stated Concern

Background

Reporting from mid-September to late October 2026 describes several organisations and individuals porting large codebases to Rust with AI coding agents doing most of the writing. This analysis compares reporting on six such cases, a count the Herald made from its own reading: Bun, GitHub’s Copilot agent runtime, OpenAI’s Habitat storage service, Theo Browne’s TypeScript port, Cloudflare’s tsrs and a Rails creator’s Campfire test. It separates what the sources report from what follows from them. The Herald covered some of these projects individually, including the Copilot runtime rewrite, Bun’s Zig-to-Rust merge and the TypeScript 7.1 beta.

The New Stack reported on September 17 that GitHub had rewritten the Copilot agent runtime, previously built in TypeScript on Node.js and V8, into more than 800,000 lines of Rust. It wrote that Microsoft engineer Stephen Toub’s blog post said the team used the GitHub Copilot app and the Copilot CLI, with the work spread across 128 pull requests, and quoted Toub: “AI agents wrote most of the code.” The same article reported that Bun founder Jarred Sumner orchestrated multiple Claude Code agents to translate Bun’s 535,496 lines of Zig, and that eleven days after starting, the Rust version was passing Bun’s existing tests on all six supported platforms. It also reported that OpenAI said two engineers working with Codex and GPT-5.5 rewrote its Habitat storage service from Python into Rust, with the new service “handling 95% of our production requests” and, according to the company, using six times less CPU and 15 times less memory.

The Register added figures for the Copilot runtime: about $120,000 in AI token usage plus about three weeks of a developer’s time, 430,000 lines of TypeScript converted into 800,000 lines of Rust, and a benchmark in which the original completed 7.55 session lifecycles per second against 120 for the Rust version, a 15.9x speedup on that workload. It counted “over 135 releases” across a 14.5-week period where The New Stack counted 128 pull requests, so the two outlets use different units for the same project.

Current situation

Who supplies the numbers. The New Stack wrote that “these various projects remain individual case studies, reported by the companies with the most to gain from demonstrating what coding agents can do on major software rewrites.” It also noted that Anthropic and GitHub are major vendors of coding agents, making their accounts “inherently self-interested.” It cautioned that the Bun timeline of eleven days and the GitHub timeline of 14-and-a-half weeks “shouldn’t be read as a Claude-versus-Copilot benchmark,” because one was a highly parallel translation between two systems languages and the other a TypeScript-to-Rust move made while the product kept shipping.

A contested comparison. The Register reported on October 7 that David Heinemeier Hansson had frontier agents implement his company’s Campfire chat app in Elixir, Go and Rust and compared them with the original Ruby on Rails version. On the “room page” task it reported 36,260 requests per second for Rust, against 241 for Rails, 722 for Elixir and 3,860 for Go. The article said many observers concluded the Rust version had been optimised and the others had not. It reported that other developers rewrote the Elixir code, after which the Elixir version beat Rust on some tasks. One observer wrote on X: “You’re not benchmarking languages, you’re benchmarking how much attention each port got.” Hansson noted on X: “It’s not exactly extra points for Elixir if frontier agents can’t find the magic ‘go fast’ switches.”

TypeScript ports. The Register reported on October 15 that Browne used agents to port the TypeScript compiler to Rust, claiming it runs twice as fast as Microsoft’s Go-based TypeScript 7 and 12.5 times as fast as TypeScript 6, although he says he has not inspected the code. According to the article, an earlier attempt using GPT-5.6 Sol and GPT-6 Astra consumed more than $400,000 of API-equivalent tokens and reached roughly 84 percent compatibility, while a later run with Claude Opus 5.5 cost about $24,000 and passed the conformance tests with nearly 100 percent accuracy.

The New Stack reported on October 20 that Cloudflare is taking ownership of tsrs, a Rust port that it claims is up to eight times faster and uses 70% less memory than TypeScript 7.0. The project began at Owner.com, where Max Schwenk wrote, “I wrote zero code,” directing Claude Opus 5.5 agents. Schwenk reported that a 37,000-file backend that took 19 GiB and 80 seconds to type-check with Microsoft’s Go compiler dropped to roughly seven seconds in CI. Daniel Rosenwasser of Microsoft said in a Hacker News discussion that “a lot of the speed does not just come down to language choice,” and that some TypeScript 7.1 optimisations came from tsrs.

InfoQ reported on October 27 that one developer benchmarked both npm packages and measured 5.3x faster checking and 72% less memory, with identical diagnostics and byte-identical emit, but found that tsrs exits with code 2 on type errors where tsc exits 1. Another tester, ImportStatic, measuring against the TypeScript 7.1 beta rather than 7.0, found a smaller 2.7x gain. InfoQ added that others questioned whether the “arena-based, never-freed memory model” is sound, that the release is experimental with no watch mode or language server yet, and that Cloudflare is merging tsrs with Browne’s port, which InfoQ calls tsc-rs, into a single package.

Verification. The Register’s Copilot article said the project met “dozens of regressions,” and quoted Toub: “‘if it compiles, it’s correct’ is useful only as a joke.” It quoted consultant Lisa Crossman at RustConf: “Rust stops the agent writing memory unsafe code; it does not stop the agent writing the wrong program correctly.” The New Stack reported that the tsrs project uses TypeScript’s conformance tests, deliberately introduces errors into real projects and runs Miri, which uncovered a memory bug that appeared only in an optimised build. It quoted Schwenk: “A faster compiler that finds fewer errors is a broken compiler with good marketing.” It also quoted Cloudflare’s Boshen Chen: “If tsrs behaves differently from Microsoft’s compiler, the starting assumption should be that tsrs has a compatibility gap that needs to be investigated and fixed.”

Implications

The points below follow from the reporting above. They are not predictions.

Most headline figures originate with the people who made the change. The Copilot runtime figures come from a Microsoft engineer’s account, the Habitat figures from OpenAI, and the tsrs headline figures from Cloudflare and Schwenk. The New Stack says so directly about the Bun and GitHub cases. Outside measurement appears in the reporting only for tsrs, where InfoQ relays two testers, and for the Campfire test, where critics reran or retuned the other languages. The reporting reviewed here contains no outside measurement of the Copilot runtime, Habitat or Bun.

The baseline changes the result. The same tsrs project is reported as up to 8x faster (against TypeScript 7.0, per Cloudflare), 5.3x (one tester, per InfoQ) and 2.7x (against the 7.1 beta, per InfoQ). In the Campfire test, retuning the Elixir code changed the ranking on some tasks. Rosenwasser’s statement that speed “does not just come down to language choice” is consistent with the TypeScript 7.1 optimisations that The New Stack and InfoQ say were informed by tsrs.

Stated reasons for choosing Rust differ by project. The New Stack reports that Sumner pointed to memory-management bugs between Zig and the embedded JavaScript engine. Toub, per The Register, said GitHub’s requirements were embedding through a C ABI, low startup and steady-state overhead, and predictable resource use, and added that the work is “in no way a claim that every large TypeScript program should become Rust.” The New Stack reports that Cloudflare points to WebAssembly, since Go must bring its garbage collector along. The sources do not present one shared rationale.

Compiling is reported as insufficient evidence of equivalence. Toub’s regressions and Crossman’s remark make this point directly, and the tsrs exit-code difference is an example of behaviour that differs from the original. The projects that describe their checks name conformance suites, fault injection and Miri (tsrs), and incremental shipping across many pull requests (Copilot runtime).

Consequences for TypeScript users are specific. InfoQ reports that tsrs tracks TypeScript 7, so teams on TypeScript 5 or 6 are advised to adopt Microsoft’s Go port first, and that the exit-code difference was enough to “quietly break a CI script” in one tester’s account, and that diagnostic order can differ. The New Stack reports that Chen expects tsrs to follow Microsoft’s compiler where the two disagree.

Open questions in the sources. The Register noted that Zig creator Andrew Kelley called Bun’s Rust code “unreviewed slop,” but no source reviewed here reports a code audit of the Copilot runtime, Habitat or Bun. The New Stack says Cloudflare has more work to do on circular types before tsrs can be considered ready for a stable release. Whether the reported cost and time savings hold outside vendor-run projects is not addressed by the reporting.