When José Valim, creator of the Elixir programming language, published a wide-ranging essay on how programming languages should evolve in an era where AI agents write most of the code, the argument boiled down to a single provocation: the tools we build for human developers are no longer sufficient, because a new kind of user is already writing code at scale.
When the User of a Language Is No Longer Human
Valim's essay, published on 24 September 2026, begins with a uncomfortable question for language designers and community builders. What happens when humans stop writing most of the code? Communities have historically rallied around shared sensibilities: Python around its emphasis on a clear way to do things, Ruby around programmer happiness, Lisp around the ability to reshape the language itself. If the people writing code are agents, what replaces that sense of belonging?
The answer is not reassuring. Valim argues that coding agents could dramatically reduce the cost of building an ecosystem, allowing smaller language communities to catch up with larger ones by implementing known algorithms, porting ideas from papers, or translating existing libraries between languages. But the same cheapness that closes gaps also weakens the incentive to collaborate in the first place. If a developer can ask an agent to build exactly the library they need, the collective effort that produces a shared framework becomes unnecessary. The tension between cheaper ecosystems and weaker community formation is, in Valim's view, one of the defining challenges ahead.
Syntax Is a Human Problem, Not a Machine Problem
Much of language evolution over the past decade has focused on ergonomics: optional chaining operators, null-coalescing syntax, concise type annotations. Valim argues that if humans are no longer writing most of the code, these changes matter far less than they appear. Agents are not bothered by boilerplate. The syntactic differences between languages that feel enormous to a human developer are, from the agent's perspective, simply different token distributions.
He goes further and dismisses the emerging category of languages marketed as being "built for AI agents" if their pitch centers on syntax. Any new language that claims agent-friendliness and ultimately optimizes for textual terseness is, in his words, building around today's limitations. He notes having used agents to write code in HTML, CSS, JavaScript, Elixir, Rust, and Lean, and that the syntax differences which dominate human discourse are considerably less important to the agents consuming them.
Why Compilers Are Not Going Away
A common question in these discussions is whether agents will simply write assembly and render compilers obsolete. Valim rejects this, for two reasons. First, no one wants to maintain different assembly implementations for every architecture a desktop application targets. An architecture-independent representation that lowers to the target machine is still necessary, which means at least part of a compiler and a higher-level language persist, even if no human ever writes that language.
Second, no single computational model excels at everything. Systems programming languages, theorem provers, concurrent and distributed language runtimes, query languages, and hardware-description languages each encode different semantics and different levels of abstraction with different guarantees. Expecting one lower-level language to unify all of them is unreasonable. The need for specialized languages, and therefore for compilers, remains intact.
What to Optimize For Instead
If syntax stops mattering, what should programming languages optimize for? Valim points to three concrete shifts in tooling philosophy.
The first is stronger guarantees. When humans write code, type inference is a convenience because writing explicit types is tedious. Agents do not experience tedium. Making types and intentions explicit gives the compiler, other agents, and developers more information to work with. More importantly, languages whose types can be fully inferred are generally a subset of those whose types can be checked, meaning that optimizing for inference limits both expressiveness and the guarantees a type system can provide. Valim argues that combining correct-by-construction, statically established, runtime-enforced, and empirically validated approaches will become an increasingly important way for languages to differentiate themselves.
The second is replacing the Language Server Protocol with queryable program databases. LSP was designed for IDEs, with operations biased toward file, line, and column references that agents do not track precisely. Valim suggests exposing language server information as a queryable database using SQLite, Datalog, or a custom DSL. An agent could compose queries that would be impractical to expose as individual IDE features, such as finding all public functions that eventually call a given function or all paths where a value can become nil.
The third is replacing debuggers with runtime observability. Breakpoints and step-through execution are designed for human pacing. Agents can instrument code, collect traces, and correlate information far faster. Runtime observability gives agents a programmatic interface to diagnose failures, identify reliability issues, and detect bottlenecks live across environments. Valim notes that the Erlang VM, which powers Elixir, already excels at this, with built-in capabilities for inspecting processes, sockets, supervisors, and message queues.
Valim's essay is not a prediction but a set of design constraints that are already binding. The question facing language designers is not whether agents will write code, but whether the languages, tools, and runtimes they depend on were built for a user that no longer looks anything like the ones who shaped them.