Version 2.6.9 of Steel Bank Common Lisp went up on the project’s news page on September 26 — twenty-nine days after 2.6.8, which is the maintenance cadence you’d expect from people with no ambitions beyond not breaking anything. Within days, an essay titled “Why Common Lisp Is Now the Best Programming Language” sat on the Hacker News front page with 278 comments underneath it, most of them relitigating parentheses.

The thread is arguing about the wrong thing. Lisp is not winning in 2026 because macros are elegant or because the REPL is pleasant. It is winning because the ANSI standard has been frozen since the mid-1990s, and a frozen language makes a perfectly stable target for a machine that has read everything.

Every Living Language Taxes Its Own Training Data

Here is the part of the pitch that never makes it into the conference talk. A language that keeps changing burns its own corpus. The JavaScript ecosystem spent a decade teaching models a framework idiom it then abandoned. Python spent a generation split between two dialects that don’t quite run each other. Go added generics; Rust keeps shipping editions; every toolchain with a foundation and a release train is quietly invalidating the examples an agent learned from.

SBCL’s release notes are the counterexample, and they are almost aggressively boring: point releases a month apart, an implementation tracking new chips and new operating systems, while the semantics underneath sit still. The compiler moves because the hardware moves. The language does not move because nobody has decided it should be fashionable. I checked the dates because I assumed someone had fat-fingered the archive.

So when an agent writes Lisp against a 2011 codebase in 2026, it is not translating between dialects. It is writing the same language it was trained on. That is not a small edge. It is the only language in wide use where the training data has not expired.

The Sharpest Objection in the Thread Is Also the Weakest

The best comment on the thread — from a pseudonymous poster five months back on a related submission — concedes the whole argument and then tries to lose it. Lisp’s advantage, this commenter says, is ergonomics for a certain kind of human. If you go fully agentic, that advantage evaporates, so you might as well use Rust.

The problem is what “ergonomics” is doing in that sentence. A human wants a syntax that fits in their head. An agent wants a target that doesn’t move while it is being aimed at. Those are different requirements, and Lisp happens to satisfy the second one almost by accident — thirty years of institutional neglect, dressed up as principle.

There is a genuine signal here that the trend pieces are missing: a Leanpub title from Mark Watson, No Black Boxes: Building a Transparent AI Coding Agent in Common Lisp, is sitting in the ebook stores right now. The convergence isn’t a forum joke. It’s a small industry forming around the one language too old to have a migration guide.

A staff engineer at a mid-sized payments company, cornered at the hotel bar after a Lisp meetup in Austin last month, made the case better than the essay did. “Our agent writes the same Lisp in 2026 that our 2011 codebase is written in,” this person said. “Nothing about the language moved. That’s the entire pitch, and you can’t put it on a conference slide.”

What the Faithful Won’t Admit, and What It Costs Their Critics

Now the uncomfortable part, and it cuts at the people nodding along.

If the advantage is frozenness, then the Lisp community’s thirty-year campaign to be taken seriously as a modern language is the single greatest threat to its own revival. Every push toward contemporary package management, every syntax modernization, every “Lisp but with familiar braces” project is an attempt to join the treadmill that made the language valuable in the first place. The correct strategic move is to stay dead. That is an ugly thing to tell a community that spent decades insisting the beauty of the thing was the point.

It gets worse for the rest of us. If stagnation is a feature, then the standard critique of COBOL, of Fortran, of SQL — that they are legacy cruft propped up by inertia — is at least partly backwards. Those languages persist because the systems written in them still run and because anything an agent generates against them is checked against a target that hasn’t moved. Novelty in a language is a cost imposed on everyone downstream. The industry has spent twenty years calling that cost “innovation” and billing it to someone else.

And yes, that includes the people who fund developer tools. A business model built on perpetual churn in the substrate has to believe that languages must evolve or die. What the front page this week actually suggests is that the market has started pricing the churn, and the pricing is unflattering.

The Lisp revival may not last. Someone will ship a popular new dialect, break the standard, and give the models a fresh decade of examples to unlearn. But for the moment, the winning move in software is not to be brilliant. It is to be finished.

Sources