Why AI Writes Better Rust Than Python

Key Takeaways

• AI models now score 80%+ on SWE-bench Verified for systems languages like Rust and Go
• Microsoft rewrote the TypeScript compiler in Go, achieving 10x speed improvement
• A Rust-based C compiler was built by 16 Claude agents for under $20,000

The Old Bargain Is Dead

For the last decade, picking a programming language was simple. You chose Python or TypeScript because the ecosystems were huge, the hiring pool was deep, and you could have a working demo by Friday. Rust, Go, and C++ offered 10x to 100x better performance. But you paid for it with months of ramp-up time, a smaller talent market, and build systems that fought you every step.

So you shipped the Python version, sold it to customers, and promised yourself you'd optimize later. You rarely did. Neither did anyone else. That was fine.

That bargain is over. AI got good at the hard languages.

Hard Languages Got Easy First

Two years ago, GPT-4 couldn't write a Rust function without hallucinating crate names. By April 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 had all cleared 80% on SWE-bench Verified within weeks of each other. The AI labs are openly optimizing for systems work: concurrency bugs, race conditions, and architectural flaws identified during the planning phase.

The explanation is counterintuitive but makes perfect sense once you see it. Developer CtrlAltDwayne put it best last month:

The same logic applies to Go and Swift. Strong type systems plus fast compile-and-check loops give AI agents the tightest iteration cycle possible. Every compiler error is a free training signal. The systems languages that were hardest for humans turn out to be easiest for agents.

What Actually Shipped

This isn't theory. Look at what landed in a single quarter.

Microsoft Rewrote TypeScript in Go

The team behind the most-used superset of JavaScript shipped TypeScript 7.0 beta last week. It's roughly 10x faster than version 6.0. They achieved this by porting the decade-old TypeScript codebase to Go.

Anders Hejlsberg's reasoning was straightforward: Go delivered most of the performance benefit at a fraction of the engineering cost. The biggest JavaScript shop on earth picked a harder, faster language for its flagship tool. They did it because the effort calculus changed under them.

A C Compiler Built by AI Agents

Nicholas Carlini, a researcher at Anthropic, orchestrated 16 parallel Claude agents to write a production C compiler in Rust. The result: 100,000 lines of code.

• Boots Linux 6.9 on x86, ARM, and RISC-V
• Compiles QEMU, FFmpeg, SQLite, PostgreSQL, and Redis
• Runs Doom
• Total cost: under $20,000 across nearly 2,000 Claude Code sessions

A C compiler written in Rust used to be a graduate thesis. Now it's a weekend project with a credit card.

A Rust Veteran's Verdict

Steve Klabnik, a 13-year Rust veteran who co-wrote The Rust Programming Language, has been watching this shift closely. When even the people who made systems programming accessible to humans are acknowledging that AI changes the equation, it's worth paying attention.

Why Type Systems Matter Now

The mechanism here is simple. Python and JavaScript are forgiving to humans because they catch errors at runtime. You write code, run it, see what breaks, fix it. That feedback loop works fine when a human is in the chair.

AI agents work differently. They generate code, check it against the compiler, and iterate. A strict type system like Rust's gives instant, precise feedback on every mistake. The model doesn't have to run the code and interpret stack traces. The compiler tells it exactly what's wrong and where.

This creates a tight loop where AI can self-correct in real time. Rust was accidentally designed for AI-assisted development a decade before anyone knew that mattered.

What This Means for Your Tech Stack

If you're starting a new project today, the old assumptions don't apply. The hiring-pool argument weakens when AI handles the learning curve. The ecosystem argument weakens when AI can read documentation and wire up dependencies. The time-to-ship argument weakens when AI writes boilerplate faster than you can copy-paste it.

Performance languages like Rust and Go used to require a serious investment. Now that investment is measured in API credits, not engineer-months.

The promise you made to yourself about making things performant later? You might actually be able to keep it now. Or better: start with performance and let AI handle the complexity you used to avoid.

The Path Forward

None of this means Python is dead. It still has unmatched ecosystem support for data science, machine learning, and rapid prototyping. The scientific computing stack isn't going anywhere soon.

But for backend services, compilers, infrastructure, and anything where performance matters? The calculation has changed. The languages that were hard for humans are now easier for AI. And that changes everything about how you should think about your next technical decision.

Frequently Asked Questions

Does AI write better Rust than Python?

Current evidence suggests yes. AI models score higher on benchmarks for strongly-typed languages like Rust because compiler feedback creates a tight self-correction loop. Every error message helps the model fix its mistakes in real time.

Should I still learn Python in 2026?

Yes, but your reasons might change. Python remains dominant for data science, ML, and rapid prototyping. However, for production systems where performance matters, the case for learning Rust or Go is stronger now that AI can help with the learning curve.

How much does it cost to build software with AI agents?

Costs vary widely by project size. As a reference point, building a 100,000-line C compiler in Rust with 16 Claude agents cost under $20,000 across nearly 2,000 sessions. Smaller projects cost proportionally less.

Why did Microsoft rewrite TypeScript in Go?

Microsoft chose Go because it delivered most of the performance benefit of lower-level languages at a fraction of the engineering cost. The TypeScript 7.0 beta is roughly 10x faster than version 6.0 as a result.

What languages work best with AI coding assistants?

Languages with strong type systems and fast compile-check loops work best. Rust, Go, and Swift all provide immediate, precise feedback that helps AI models self-correct. Dynamic languages like Python and JavaScript offer less structured feedback.

Source: Hacker News: Best / Noah Mitchem