As AI coding agents increasingly write and modify code, the fundamental assumptions behind programming language design are being questioned. In his essay 'Evolving programming languages in the AI era,' José Valim argues that the rise of agentic AI necessitates a reevaluation of what programming languages optimize for. He splits his analysis into two parts: Reflections, which contemplates how agents might reshape language communities, ergonomics, and the very role of compilers; and Agentic tooling, which offers concrete suggestions for making languages better suited to AI-assisted development.
Valim's Reflections begin with the impact on communities and ecosystems. He notes that AI agents could dramatically reduce the cost of building language ecosystems by automating the creation of frameworks, libraries, and tooling, potentially allowing smaller communities to catch up with larger ones. However, this same efficiency risks weakening the collaborative forces that drive ecosystem formation, as developers might prefer to ask an agent for a custom solution rather than contribute to existing open-source projects or join community efforts around shared abstractions.
The essay then turns to ergonomics and compilers. Valim observes that syntactic conveniences designed to reduce human tedium—such as optional chaining operators—offer diminishing returns when agents write most of the code, since agents are unfazed by boilerplate and token efficiency becomes less critical as AI models grow cheaper and more context-rich. Regarding compilers, he contends that agents are unlikely to replace them entirely because developers still need architecture-independent representations to support multiple hardware targets, and no single low-level language can unify the diverse semantics and guarantees required by systems programming, theorem proving, concurrent software, and other specialized domains.
In the Agentic tooling section, Valim suggests that language designers should shift focus from human-centric ergonomics to stronger guarantees when balancing expressiveness and safety. Because agents do not share human aversion to boilerplate, investing in syntactic sugar yields limited benefits; instead, emphasizing correct-by-construction design (making invalid states hard to express), static analysis (types, proofs), runtime-enforced properties (memory safety, isolation), and empirical validation (testing, fuzzing) can provide agents with richer information without sacrificing expressiveness.
Valim also critiques the traditional Language Server Protocol (LSP) as a poor fit for AI agents. Originally designed for IDEs and document-centric workflows, LSPs force agents to navigate source files piece by piece to gather information—a process misaligned with how agents consume data. He proposes exposing the underlying language-server data (symbols, references, call graphs, type information, data-flow) as a queryable program database using tools like SQLite, Datalog, or a custom DSL, enabling agents to efficiently ask complex questions such as 'find all public functions that eventually call this function' or trace values through a program.
Finally, Valim advocates for runtime observability over debuggers as the primary interface for AI agents. While debuggers rely on human-operated breakpoints and step-through execution, agents can instrument code, collect traces, and correlate information at machine speed. He points out that the Erlang VM—which powers Elixir—already offers deep runtime introspection capabilities (inspecting processes, sockets, applications, supervisors, ETS tables, message queues, and more) and argues that exposing these features safely to agents would allow them to diagnose failures, identify reliability issues, and detect bottlenecks across all environments in real time.