Agents Don't Care About Your Language Choice

Armin Ronacher published "Fast and Hard Code" two days ago. If you write code for a living — or have agents write it for you — it's the most important thing you'll read this month. Not because it announces anything new. Because it names the trend that everyone's already feeling but hasn't articulated:

LLMs make language choice much less consequential than it used to be. If you don't like the choice, you can seemingly rewrite it in another language and you can make it pick a language that you, as a programmer, are entirely unfamiliar with.

The result? People are shipping Rust and Zig code who never would have touched them six months ago. Not because they learned the language. Because they told an agent what they wanted and got back something that compiles.

The Hard Language Renaissance

Armin catalogues the pattern with concrete examples:

• Cloudflare Artifacts — a pure-Zig Git protocol engine compiled to a ~100 KB WebAssembly module
• Vercel fx — a Zig coding agent, intentionally small and fast
• Stuff with DWARF files, eBPF, custom network drivers, custom crypto — previously gatekept domains now being explored by developers who'd never have attempted them

I can add my own. Prime Intellect's NanoGPT Speedrun Frontier — which I covered yesterday — ran 153 autonomous optimization runs across 18 frontier models. The winning harness (Fable 5 on Claude Code, closing 81.7% of the human record gap) generated CUDA kernels, custom optimizer code, and low-level training infrastructure. The agents didn't care that this is hard C++ with GPU intrinsics. They just wrote it.

This isn't a hypothetical future. It's what shipped this week.

Why This Actually Matters

The obvious read is "AI makes hard things easy." True but shallow. The deeper shift is about who gets to participate in systems programming.

Before agents, writing a custom Git engine in Zig required: fluency in Zig, deep understanding of the Git protocol, Wasm compilation targets, and months of debugging. Now you prompt through it in a weekend. The barriers weren't technical — they were knowledge gatekeeping disguised as expertise requirements.

Armin nails this:

Many of these things were previously off-limits for lots of developers. In some cases (eg: crypto) you were even pushed away because those things were intentionally gatekept by the people in the know.

The agent doesn't know it's supposed to be hard. So it just does it.

The Hidden Catch

But Armin also flags the asterisk that matters:

With things like autoresearch you don't even necessarily need to know all the tricks — you just need to put an agent on it — though knowledge greatly helps!

I've been running autonomous research agents on Dispatch for two weeks. The pattern is consistent: agents are only as good as the terrain they're navigating. If you know the landscape — the sharp edges, the hidden dependencies, the things the docs get wrong — your agent produces production-quality output. If you don't, you get code that compiles and then fails in ways you can't debug.

The agent lowers the barrier to entry. It doesn't eliminate the value of experience.

What This Means for the Next Six Months

graph LR
  A[Prompt: \"Build a fast thing\"] --> B[Agent]
  B --> C{Rust, Zig, C, Go?}
  C -->|No expertise needed| D[Picks best tool for job]
  D --> E[Compiles on first try]
  E --> F{Works?}
  F -->|Yes| G[Ships fast]
  F -->|No| H[Needs domain expert to debug]
  H --> I{Expert available?}
  I -->|Yes| J[Fixed]
  I -->|No| K[Abandoned or rewritten]

The bottom line: more code will be written in "hard" languages, and more of it will work out of the box. But the long tail of production issues — the ones that require understanding memory ordering, cache locality, or protocol edge cases — will still demand humans who know the terrain.

The Bottom Line

Armin's piece ends on a perfect note:

So maybe the world will have more slop, but it might also have more developers in it, that want things to be fast and small.

That's the bet. More code, more languages, more ambition — enabled by agents that don't know they're supposed to be intimidated. The gatekeeping is dead. What replaces it depends on whether we use these tools to learn the hard stuff or just skip past it.

I know which camp I'm in. But the market will decide.