If AI Writes Your Code, Why Use Python? (Mitchem)

Noah Mitchem's April 28 2026 Medium essay argues that the last decade's default — start a new project in Python or TypeScript because humans ship faster in them — is now wrong, and the reason is mechanical: agents got good at Rust and Go before they got good at anything else, so the languages that punished humans the most have the smallest agent-tax. See language-choice-for-agents for the standalone concept.

The bargain that broke

For ten years, the language choice for a greenfield project was a tradeoff between developer speed and runtime speed, and developer speed always won. You picked Python because the ecosystem solved most problems already and you could demo on Friday. You knew Rust or Go would give you a 10–100× speedup, but you paid in six months of ramp, a smaller hiring pool, and a build system that fought back. The performant rewrite was always somewhere on the roadmap and rarely happened.

Mitchem's claim is that this calculus inverted because the constraint that produced it — humans are slow at low-level languages — went away.

What actually shipped in Q1 2026

The essay's strongest section is empirical rather than rhetorical. Four artifacts landed in one quarter, each of which would have been a multi-year project before:

• Microsoft ported the TypeScript compiler to Go. TS 7.0 beta is roughly 10× faster than 6.0. Hejlsberg's justification was that Go delivered most of the performance benefit at a fraction of the engineering cost — the calculus changed under them, not the requirements.
• Nicholas Carlini built a C compiler in Rust with 16 parallel Claude agents — 100,000 lines, boots Linux 6.9 on x86/ARM/RISC-V, compiles QEMU, FFmpeg, SQLite, PostgreSQL, Redis. Runs Doom. Cost: under $20,000 across ~2,000 Claude Code sessions.
• Steve Klabnik built a new systems language (Rue) in two weeks. ~70,000 lines of Rust. He framed it as faster progress than the same project got over a previous month-or-two of solo work.
• Andreas Kling ported Ladybird's JavaScript engine from C++ to Rust in two weeks by directing Claude Code and Codex through hundreds of small prompts. ~25,000 lines, byte-for-byte parity, zero regressions across 65,000+ tests.

The implicit argument: a C compiler in Rust used to be a grad thesis. None of the four would have been possible in 2024, were marginal in 2025, and are now commonplace.

The mechanism: tight feedback loops

Mitchem quotes CtrlAltDwayne — the argument for Rust in 2026 isn't memory safety or runtime speed, it's that compiler errors are a free training signal and the iteration loop is short enough for models to self-correct in real time. Strong types plus fast compile-and-check plus large training corpus = the tightest agent loop. The languages that were hardest for humans are the easiest for agents for exactly the reason they were hard: pedantic compilers run all the time.

This is a different argument from "AI is good at Rust because there's a lot of Rust on GitHub." Training-data volume is necessary but not sufficient. The corpus argument explains why Rust and Go work and Zig/Haskell/Gleam lag; the feedback-loop argument explains why Rust beats Python at agent throughput even when both have plenty of training data. Both reinforce the same conclusion. See scaffold-model-fit for the related framing that scaffold quality dominates over base-model quality.

The ecosystem isn't what it used to be

The strongest argument for Python and JavaScript was always the ecosystem. Mitchem's counter: the ecosystem is increasingly Rust under a Python hat. import pydantic pulls in a Rust validation core. Polars is Rust. orjson is Rust. Hugging Face tokenizers are Rust. The JetBrains 2025 survey shows Rust extensions for Python jumped from 27% to 33% in a year. Astral's ruff/uv/ty are Rust. The plumbing already moved.

The corporate signal is the acquisition pattern:

• OpenAI acquired Astral on March 19, 2026. Internal justification: uv saves Codex ~1M minutes of compute per week. Astral's stack is documented in detail at open-source-security-astral.
• Anthropic acquired Bun ten weeks earlier (7M monthly downloads, 89K GitHub stars), framing it as "essential infrastructure for AI-led software engineering."
• Evan You's VoidZero shipped Rolldown-Vite (Rust bundler) cutting GitLab's 2.5-minute build to 40 seconds with 100× less memory. Lee Robinson at Vercel: "We've reached peak optimization with JS."

The packages you import in Python and JS are increasingly wrappers around code that was previously hidden behind a binding because nobody on the team could ship it. Once agents can write that lower layer directly, the binding becomes overhead. See port-not-patch-contribution for the deeper structural shift.

Patch → port

The old open-source loop: pick Python because it's easy → find a bug in a dep → fix it → upstream → ecosystem gets healthier. Mitchem's strongest novel claim is that this loop broke in a specific way — the unit of contribution shifted from the patch to the port. His existence proof is Ronacher porting MiniJinja from Rust to Go in 45 minutes of human time, 10 hours of agent time, for $60 in API costs. If forking a library across languages takes one work session, upstreaming a fix to someone else's library is comparably expensive but leaves you depending on their release cadence and review attention.

Ronacher's pull-quote: the value is shifting from the code to the tests and documentation. A good test suite is worth more than the code now, because the code is fungible across languages and runtimes. See lucumr-blog for context on Ronacher's broader 2026 writing on agent tooling.

The structural argument lives at port-not-patch-contribution. The corollary worth flagging: PyPI and npm still work today; it's not obvious they work in 2028 if every shop with a code-incompatibility friction reaches for a fork-and-port rather than a coordinated upstream.

Where Mitchem hedges

The essay is unusually honest about its limits.

Some projects still want the old answer. Prisma removed its Rust query engine in favor of a TS/WASM core — bundle size dropped 85%, queries got up to 3.4× faster. Native Rust binaries are hostile to serverless runtimes. PyTorch still owns ~85% of deep-learning research because the model weights don't care about the wrapper language.

AI is not equally good at every systems language. Zig, Haskell, and Gleam are smaller corpora and produce worse AI output. The Stack Overflow most-admired ranking (Rust 72%, Gleam 70%, Elixir 66%, Zig 64%) is interesting precisely because the second-tier languages have the human preference but lack the agent quality. This sits in direct tension with simonw-zig-anti-ai: Zig is explicitly refusing the LLM contribution lever, which is the same lever that would close the quality gap. Both essays are correct about the mechanism; they disagree on whether agents-write-the-language is desirable.

How this sits in the wiki

Mitchem's piece is the most aggressive empirical case for the agent-language thesis the wiki has. It deserves to be read against:

• no-silver-bullet-llms — Bennett's argument that the essential-vs-accidental ceiling caps LLM gains; DORA and CircleCI data show rising instability, not just productivity. Mitchem's "100k-line C compiler for $20k" is the kind of artifact Bennett's framework predicts is most amenable to LLM gains: dense accidental complexity, narrow correctness criterion, the compiler runs all the time. The two frames aren't strictly in opposition — they describe different parts of the work surface — but the framing matters.
• skill-atrophy-supervision-paradox — Lars Faye's argument that agent oversight requires the very skills agent use erodes. Mitchem implicitly assumes the "architect and review" worker still exists at scale; Faye argues that population shrinks faster than agent output grows.
• agentic-coding-fatigue — 0xsid's data point that the supervisor role has a ~4–5 hour daily ceiling. If Mitchem's loop runs against Faye's wall, the bottleneck reasserts itself at the human end.
• i-am-an-ai-hater and i-will-never-use-ai — the refusal cluster. Mitchem's argument is the engine; these are the brakes.
• ai-great-leap-forward — the structural-failure-mode argument: mandates to use agents produce fabricated metrics. Mitchem's TS-7-in-Go example is the well-executed-version; the Great Leap argument is about what happens in the median shop.
• ai-assisted-workflow and simonw-vibe-coding-agentic — what the practitioner side of the architect-and-review job actually looks like in practice.

The clean way to read Mitchem alongside the skepticism cluster: he is right about the artifacts and the mechanism. The question is whether the artifacts generalize from "skilled engineers with strong domain models porting things they already understand" to "median teams starting greenfield projects in languages no one knows." The cited example (the Tauri/Rust Mac app at 1/10th the Electron size, engineers who didn't know Rust) is the claim. The wiki's accumulated skepticism is the counter-evidence.

Pull quotes worth keeping

"The best argument for Rust in 2026 is not memory safety or performance. It is that AI writes better Rust than it writes C++. The compiler feedback loop is so tight that models self-correct in real time. Every error message is a free training signal." — CtrlAltDwayne

"The biggest reason new languages might work is that the cost of coding is going down dramatically. The result is the breadth of an ecosystem matters less." — Ronacher, A Language For Agents

"LLMs change the whole constraints landscape of software completely … even Rust is nowhere near optimal for LLMs as a target language." — Karpathy

"The future of programming won't be languages easiest for humans. It'll be languages easiest for agents." — @RealRichomie, Apr 24 2026