Your coding agent writes Rust now. Python is baggage.
That Python ergonomic advantage you have been riding for a decade? AI just neutralized it. When your agent writes Rust as fast as it writes Python, and the Rust binary runs 100x faster in production, the calculus changes. The future of programming is not about languages that are easiest for humans. It is about languages that are easiest for agents.
The Data Points That Change Everything
Microsoft Rewrote TypeScript in Go and Got 10x
Microsoft shipped TypeScript 7.0, codenamed Project Corsa, by rewriting the compiler from TypeScript/JavaScript to Go. The numbers are hard to argue with. VS Code project load dropped from 9.6s to 1.2s. Memory usage cut in half. Across the VS Code codebase (1.5 million lines), compilation went from 77.8s to 7.5s. That is not incremental. That is a new class of developer tool.
Anthropic Built a C Compiler in Rust for $20K
Anthropic researcher Nicholas Carlini ran 16 parallel Claude Opus 4.6 agents to build a production-grade C compiler from scratch. The results: 100,000 lines of Rust, roughly 2,000 autonomous sessions, two weeks of wall clock time, and $20,000 in API fees. The compiler passes 99% of GCC torture tests and compiles Linux 6.9 on x86, ARM, and RISC-V. It also compiles QEMU, FFmpeg, SQLite, Doom, Redis, and PostgreSQL. The agents ran in isolated Docker containers, resolved their own merge conflicts, and worked in parallel with a file-based locking mechanism. A task that would have taken a team of senior engineers months cost $20K and two weeks.
Ladybird Ported 25K Lines of C++ to Rust in Two Weeks
The Ladybird browser team ported their entire LibJS JavaScript engine from C++ to Rust. Human-directed, not fully autonomous — lead developer Andreas Kling used Claude Code and Codex with hundreds of small prompts over two weeks. The constraint was strict: byte-for-byte identical AST output between the C++ and Rust pipelines. Twenty-five thousand lines of Rust. Zero regressions across 52,898 test262 tests and 12,461 regression tests. No performance regressions. A manual port would have taken months.
The Acquisitions Tell the Story
OpenAI acquired Astral , the company behind uv, ruff, and ty , because their Rust-based Python tools saved OpenAI millions of minutes in compute time. Fast linting, type-checking, and package resolution directly translates to faster CI/CD for AI coding agents. On the other side, Anthropic acquired Bun, the high-performance JavaScript runtime, as Claude Code hit a $1 billion revenue run rate. Claude Code ships as a Bun executable to millions of users. When your coding agent has a billion-dollar run rate, you own the runtime.
Mistral Medium 3.5: Open Weight Cracks 77% SWE-Bench
Mistral released Medium 3.5, a dense 128B parameter model, open weight under a modified MIT license. The specs: 256k context window, 77.6% on SWE-Bench Verified, 91.4% on the τ3-Telecom agentic benchmark. It merges instruction-following, reasoning, and coding into a single set of weights. This is the first truly open model at this tier to crack these benchmarks. You can run it locally with vLLM or SGLang.
The Benchmark Gap: Rust vs Python
The raw performance numbers have not changed, but the access barrier has. Rust is still up to 100x faster than Python on CPU-bound tasks. Ruff runs 10-100x faster than equivalent Python linting tools. Discord cut p99 latency from 400ms to 40ms by migrating a single service to Rust. Cloudflare's Pingora proxy (Rust) handles 1 trillion requests per day with 70% less CPU than Nginx.
So What , and What Breaks
The numbers are real. The TypeScript Go port, the Anthropic C compiler, the Ladybird Rust rewrite, these are not toy experiments. They are production systems shipping to millions of users. The direction is clear: AI agents make systems languages accessible, and teams are already moving.
But the thesis has cracks.
The Prisma case study is instructive. Prisma's Rust-based query engine produced 10MB binaries that caused cold start problems in serverless deployments. They rewrote in TypeScript/WASM and cut bundle size by 90%. Rust is not a universal answer.
There is also the GitHub data lottery. LLMs are trained on massive corpora of public code. Languages with thin GitHub footprints , Zig, Haskell, Gleam, OCaml , do not benefit from AI-assisted coding the same way Python, JS, Rust, and Go do. The AI advantage compounds only for languages that already won the data race.
And PyTorch remains dominant in ML. Eighty-five percent of published papers use it. Python will stay in ML research because that is where the mindshare is, not because of language ergonomics.
What is actually happening is more nuanced than Python is dead. The shift is that the default language for new projects is no longer automatically Python. When your agent writes Rust as well as it writes Python, and the runtime cost of Rust is a fraction of Python, the break-even point shifts hard. The constraint that humans write the code is gone. Developers are moving from writing syntax to architecting systems and reviewing AI output. That changes which languages win.
The best argument for Rust in 2026 is not memory safety or performance. It is that AI writes better Rust than it writes C++, and the compiler feedback loop is so tight that models self-correct in real time.