José Valim, the creator of the Elixir programming language, has published a detailed reflection on how programming languages and their tooling may need to change when AI agents become the primary writers of code. The essay, split into two parts, raises uncomfortable questions about the communities, ecosystems, and design priorities that have shaped software development for decades, and offers concrete suggestions for what tools should look like in a world where coding agents are first-class users of every language.
When Communities Stop Writing Code
Valim begins by examining what happens to the social fabric of programming languages when humans are no longer the primary authors of code. Every major language community rallies around a shared sensibility: Python emphasizes an obvious way to do something, Ruby cultivates programmer happiness, Lisp communities celebrate the ability to reshape the language itself. These shared values are what bind developers together and give them a reason to participate.
When agents take over most of the coding, that sense of belonging comes under pressure. Valim does not predict the demise of language communities but asks whether something else will need to glue them together. He notes that the same shift could affect ecosystems in two opposing directions.
On one hand, the gap between ecosystems could narrow significantly. Building frameworks, libraries, and tooling requires considerable effort, much of which agents could trim. Smaller communities could catch up with larger ones quickly, especially when implementing known algorithms, translating ideas from research papers, or porting existing solutions between languages becomes a matter of asking an agent rather than organizing a team.
On the other hand, if implementing anything becomes cheap enough, the incentive to collaborate on a single shared solution weakens. Valim frames this as a genuine tension: coding agents could dramatically reduce the cost of building an ecosystem while simultaneously undermining one of the forces that causes ecosystems to form in the first place.
Ergonomics May Stop Mattering
One of the most provocative claims in the essay is that syntactic ergonomics, which have driven language evolution for years, may become far less relevant. The addition of optional chaining operators, for example, made life noticeably easier for human developers, but agents are indifferent to boilerplate. Valim argues that token efficiency is at the tail end of what programming languages should optimize for, especially as models become cheaper and context windows grow larger.
He goes further, stating that any new language claiming to be built for coding agents that ultimately focuses on syntax is effectively building around today's limitations. Valim reports having used agents to write HTML, CSS, JavaScript, Elixir, Rust, and Lean, and notes that the syntactic differences that feel enormous to him appear considerably less important to the agents themselves. From an agent's perspective, the process is fundamentally tokens in and tokens out.
Why Languages Are Not Going Away
A common question in these discussions is whether programming languages will still be needed at all if agents can generate code directly. Valim rejects that scenario for two reasons.
First, maintaining different low-level implementations for every target architecture is impractical. Even if agents wrote assembly, developers would still need an architecture-independent representation that could be lowered to the target machine, which means reinventing at least part of a compiler and a higher-level language.
Second, no single computational model excels at everything. Systems programming, theorem proving, concurrent and distributed computing, querying, and hardware description all encode different semantics and guarantees. It is unreasonable to expect a single lower-level language to unify all of those domains.
What Languages Should Optimize For Instead
If languages are not going away but humans are no longer optimizing them for human writers, Valim argues they should optimize for stronger guarantees. Programming languages balance expressiveness, guarantees, and ergonomics. If agents are writing most of the code, the ergonomics trade-off can be revisited, and more emphasis can shift toward guarantees that make software correct, safe, and verifiable.
Valim outlines four approaches that languages can combine: correct by construction, where invalid states are hard or impossible to express; statically established, through types, proofs, and static analysis; runtime-enforced, through memory management, isolation, and capability boundaries; and empirically validated, through tests, property-based testing, and fuzzing. He believes the way languages combine these techniques will play an increasing role in how they differentiate themselves and get adopted.
Program Databases, Not Language Servers
Valim makes a practical argument about developer tooling. The Language Server Protocol, which powers most modern IDEs, was designed for human consumption and is biased toward documents, lines, and columns, which agents do not track precisely. He suggests replacing LSPs with program databases that expose symbols, references, call graphs, type information, and data-flow information through a query language, whether that is SQLite, Datalog, or a custom DSL.
Agents would gladly compose complex queries that would be impractical to expose as individual IDE features. They could find all public functions that eventually call a given function, or trace every path where a value can become nil. The same databases could serve as linters to guard agents against undesired practices.
Observability Over Debugging
Finally, Valim argues that debuggers, designed around human workflows of setting breakpoints and stepping through code line by line, are the wrong interface for agents. Agents can instrument code, collect traces, and correlate information far faster than a human can follow a step-by-step execution. He calls for runtime observability interfaces that let agents query and explore system state programmatically.
He points to Elixir and the Erlang VM as an area where this already exists in a strong form, with built-in capabilities for inspecting processes, sockets, applications, supervisors, and message queues. The remaining challenge is exposing those capabilities safely to agents through tools, query interfaces, or sandboxes.
The essay is a call to action for language designers and tool builders. The assumptions that shaped decades of programming language development, the emphasis on ergonomics, the focus on human-readable syntax, the IDE-centric model of development, may no longer apply in a world where the primary user of a language is an agent that does not read the code it generates.