The joy of reading the code

On simplicity, AI-generated code, and why the aesthetics of a language still matter

Recently, I sat down to record a Beyond the Commit episode with José Valim - creator of the Elixir programming language. We ended up talking for over 2 hours — about types, about AI, about where programming languages are headed.

It got me thinking. I've been picking up Elixir on and off for years — for personal projects, for POCs — then drifting back to whatever serious, enterprise language the day job demands. But I kept returning. And the reason is simpler than I expected.

I realized I genuinely enjoy reading Elixir code.

I've spent years reading code in various languages, and for most of them, "reading" is something I endure, not something I look forward to. It’s a means to an end.

What makes Elixir different is its simplicity. Pipe operators, pattern matching, protocols — each construct is just powerful enough to be flexible and useful, yet simple enough that the code stays readable.

Now, many other languages have achieved simplicity (Golang). But none that I know of has achieved this level of balance of simplicity and harmonious aesthetics (at least for me).

There's a narrow design corridor that Elixir walks remarkably well.

Contrast this with Scala, which I used to know well. Well-written Scala code is a joy to read. Poorly written Scala code is the ninth circle of hell.

Elixir gently constrains you toward clarity, and the result is that most Elixir code reads roughly the same way. Which is exactly what you want when your job is reviewing it.

This philosophy transcends the language itself and extends to its ecosystem. For my personal projects, I've been using Django for a few years now. I typically had to wire up hot reload, Stimulus, Tailwind, recurring jobs, and whatnot myself. It all ended up in a custom-made cookiecutter template eventually. In Phoenix, all of that comes built in as a single coherent package — powerful enough to be flexible, simple enough to pick up and start building immediately. Neat, elegant package.

Here’s the part I find counterintuitive. We’re living through a moment where people are debating whether hand-writing code even matters anymore. AI writes the code, you review and guide it. I think that actually makes the aesthetics of a language matter more, not less. If your main interaction with code is reading it, then how pleasant that experience is becomes a first-class concern. At least while we're still expected to understand the code we ship…

The conventional wisdom right now is that statically typed languages are better suited for AI-assisted development. Types give the model more context, catch errors earlier, and constrain the solution space. It makes intuitive sense, and maybe it is so. It certainly is a convincing argument for enterprise-grade software.

Meanwhile, we also have some interesting experiments like this one, testing the cost of generating (correct) pet projects. Yusuke Endoh tested Claude Code across 13 languages — Ruby came out on top. Fastest, cheapest, most reliable. Adding a type checker to Ruby made it 2-3x slower. Concise, expressive languages — the ones pleasant for humans to read — are also the ones where AI wastes the least tokens.

(There is also this interesting piece from José himself about the tension related to the impossibility of typing some trivial expressions correctly without type unsoundness, but that’s a completely different story)

In the meantime, OpenAI just built Symphony — their agent orchestration framework — in Elixir. A frontier AI lab reached for a language built on a 40-year-old virtual machine designed for telephone switches to orchestrate its agents.

There’s something poetic about that. In a world where AI handles more of the writing, what remains - at least for the time being - is taste, clarity, and the pleasure of working with something well-designed.

And Elixir has that in spades.