If your AI agent is writing the code, does it matter what language it’s in?

Of course there are practical concerns—you’re not building the next hot iPhone app in R (sorry Ethan!)—but if you’re picking from among the languages generally fit for your purpose, does it matter which one you choose?

The internet certainly thinks so.

Adam Benenson makes the case for Rust:

This is where Rust quietly becomes one of the strongest substrates available. Not because it’s fast (though it is). Not because it’s safe (though it is). But because the compiler turns a stochastic process into something that converges.

On the pretty-much-entirely-opposite side of the spectrum, Ivan Willig spent a year using LLMs to write Clojure, with good results:

Clojure is designed to be interacted with from the REPL. This turns out to be a huge advantage when working with an LLM. For example, instead of defining a new skill for each library, I taught the LLMs about clojure.repl. This allows the LLM to dynamically explore any Clojure library on the REPL. Individual skills or lessons became less important, and the platform itself served as a dynamic feedback loop.

Even Go has its champions:

I think by pure luck, Go might have landed in a sweet spot of usability, performance, and ubiquity that makes it a very good fit for agents. They write beautiful Go, they run, compile, test, format, and deliver performant software in Go that can be used across a variety of machines. All of these benefits are already available today to anyone who wants to build new tooling: just tell Claude Code to build you a CLI in Go, sit back, and enjoy the result.

And of course everyone loves TypeScript, right?

Rust has strong types and good compiler errors. Clojure was purpose-built for REPL-based development, originally for humans but now agents get to use it too. Go is simple, has strong opinions, and has a clear “right way” to do things. TypeScript has a decent type system, a good LSP, and so, so many lines of example code to train a model on.

Everyone’s right, because they’re all making the same argument without realizing it. What all of these languages have in common is a strong feedback loop.

It’s not types vs. dynamic, or compiled vs. interpreted. It’s about how fast the agent finds out it’s wrong, and how clearly the error tells it what to fix. Rust’s compiler, Clojure’s REPL, Go’s opinionated toolchain, TypeScript’s LSP—these are all feedback loops with different profiles. None is complete on its own. But each one you stack is a layer of signal between the agent and you, and each layer means one less thing you have to catch by reading diffs.

I think there’s something deeper here, too. The feedback loops that actually help agents converge seem to share a property: they’re local. A small change in code produces a small, relevant change in diagnostic output. The bad loops are global and lossy—a small change produces a wall of unrelated errors, or no signal at all until something crashes at runtime (cough Python). That locality property has a name in mathematics, and I suspect it’s the thing that actually predicts which setups work best for agentic coding.

But that’s for another post.