Every programming language is a small nation with a state religion. Python worships the one obvious way to do something. Ruby is a long-running cult of programmer happiness. Lisp’s faithful have always celebrated their power to reshape the language itself. In a new essay, “Evolving programming languages in the AI era,” programmer José Valim asks the awkward ecclesiastical question: what happens to the congregation when nobody is personally writing the code anymore?
Valim splits his musings into two halves — reflections on languages and communities, and concrete opinions about tooling — and he is upfront that the premise is contentious. Agents writing most of the code is already reality for many teams, he notes, so the question deserves exploration whether or not you believe it becomes universal. One Hacker News commenter dismissed the whole post as corporate blogspam; the questions themselves, however, are the sort the industry will have to answer either way.
Ecosystems may get cheaper to build and harder to care about
Languages accrete ecosystems — web frameworks, tensor libraries, GUI toolkits — built by communities grinding through hard problems together. Valim sees agents cutting this two ways. The gap between ecosystems could shrink, because implementing known algorithms or porting existing work is exactly the kind of labor agents trim down, letting small communities catch up fast. But the same cheapness dissolves the reason ecosystems form: if you need a library for problem X, why join a years-long collaboration when you can just ask an agent to build the thing you need?
A Hacker News commenter, imtringued, pushed the thought further: “This is deeply unintuitive but AI negates language specific ecosystems, while strengthening language agnostic ecosystems.” If any ecosystem can be ported anywhere on demand, their argument runs, the only defense is to exist everywhere at once — at which point porting becomes a meaningless exercise and the moat is filled with its own water.
Syntax is for creatures with thumbs
Much of language evolution has been ergonomic — a decade’s worth of optional chaining operators arrived mainly to spare humans tiresome null checks. Agents, Valim points out, are unbothered by boilerplate. He concedes the argument that terse syntax saves tokens, then waves it off as the tail end of what languages should optimize for, given cheaper models and bigger context windows. Having used agents to write HTML, CSS, JavaScript, Elixir, Rust and Lean, he reports that distinctions which feel enormous to a human seem to register very little: “From their perspective, it is all tokens-in, tokens-out.” Any new language advertised as “for coding agents” that focuses on syntax, he says flatly, is building around today’s limitations.
Will we even need languages? Why shouldn’t agents skip the middleman and write assembly directly? Valim doesn’t buy it. Maintain a desktop app in per-architecture assembly and you will, in short order, reinvent an architecture-independent representation plus something that lowers it to the machine — which is to say, a compiler and a higher-level language, even if no human ever reads it. And no single computational model excels at everything: systems languages, theorem provers, query languages and concurrency models encode different semantics and different guarantees.
If not ergonomics, then guarantees
Languages constantly trade among expressiveness, guarantees and ergonomics, and if the ergonomic audience retires, the bargain shifts. Take inferred function signatures: lovely for humans, who find explicit types tedious. Agents don’t experience tedium, and explicit types hand the compiler — and other agents — more to work with. Worse, Valim notes, languages whose types can be fully inferred are generally a subset of those whose types can be checked, so optimizing for inference quietly caps both expressiveness and guarantees. Why accept that ceiling for entities already capable of writing proofs in far more demanding systems?
Guarantees needn’t all be static, either: memory safety can arrive via garbage collection at runtime, model checking can validate a real system against model-generated traces, and Erlang/Elixir trade expressiveness for isolation and fault tolerance through message-passing processes. Valim lists four combinable strategies — correct by construction, statically established, runtime-enforced and empirically validated via tests, property-based testing and fuzzing — and predicts that how languages mix them will increasingly determine which ones get adopted. The essay’s second half turns practical, arguing for tools that let agents do things humans find too tedious to attempt; even a team using agents for 20% of its code, he says, stands to gain. The published excerpt ends at a suggestive heading — “Program databases over LSPs” — leaving the rest to the reader’s imagination.
The makings of a punchline are buried in his compiler argument. The vision of agents abandoning languages to commune directly with the machine collapses because the moment such an agent needs its code to run on more than one chip, it dutifully reinvents the compiler — humanity’s least glamorous invention, rediscovered from first principles by an intelligence that was supposedly beyond it.