By ByteBot
José Valim, creator of Elixir, published a sharp argument this week that language designers have been optimizing for the wrong thing for decades. In a post on September 24, 2026, he argues on the Dashbit blog that as AI agents write more code, syntax ergonomics — the obsession of language teams for 50 years — becomes nearly irrelevant to programming language design in the AI era. What matters instead: stronger guarantees, queryable program databases, and runtime observability. The post is trending on Hacker News today, and it deserves serious engagement from developers who care about where their tools are heading.
The Ergonomics Collapse Nobody Wants to Admit
Valim’s central claim is blunt: agents don’t care about boilerplate. Optional chaining operators, syntax sugar, concise method chaining — these features exist to make code nicer for humans to write. When an AI generates the code, none of that matters. His quote cuts cleanly: “agents are not bothered by boilerplate and the difference is much less meaningful.” Token efficiency gets the same treatment. “Token efficiency is at the tail end of the characteristics we should optimize programming languages for, especially as models become cheaper, more efficient, and context windows grow larger.”
This directly calls out a genre of announcements that has proliferated in 2026: AI-native languages or language features designed to be more efficient for LLMs to parse. Valim dismisses these as “building around today’s limitations.” From an agent’s perspective, HTML, Elixir, Rust, and JavaScript are largely interchangeable — tokens in, tokens out. The syntax diversity that programming language teams spend years arguing about disappears into the model’s context window.
This is a hard argument for language teams to hear, and it shouldn’t be taken as “syntax never matters.” Humans still read and review agent-generated code — a point we’ll return to. However, the trend is real: the marginal value of the next syntax improvement is declining as AI coding agents take on more of the writing load.
What Should Replace Ergonomics: Program Databases
Valim’s more constructive argument is about what language tooling should actually become. Language Server Protocols work through document-position queries — file, line, column. That design makes sense when a human cursor sits somewhere in a file. Agents don’t work that way. They ask broader questions: “Where is the documentation for this function?” “What are all the code paths where a value might become nil?” “Which public functions eventually call this method?” LSPs handle these poorly, requiring multiple round-trips for what should be single queries.
His proposal: expose the information LSPs already accumulate — symbols, references, call graphs, type information, data-flow graphs — through a queryable program database. SQLite, Datalog, or a custom DSL would let agents compose complex queries in a single operation. Furthermore, this is not science fiction. Valim’s own tool, Tidewave, already embeds an MCP server inside web applications (Phoenix, Rails, Django, FastAPI, Flask, Next.js), giving AI agents live runtime data: database schema queries, log inspection, and in-process code evaluation. It’s the pattern he’s describing, built and shipping today across six frameworks.
The Erlang Advantage: Runtime Observability as a First-Class API
The most concrete section of Valim’s argument concerns runtime observability. Traditional debuggers are human-centric: set a breakpoint, step through lines, inspect a variable. Agents can instrument code programmatically, collect traces across an entire execution, and correlate information far faster than any human could. The problem is that most programming languages don’t expose their runtime state in a queryable way.
The Erlang VM, which powers Elixir, is the exception. Inspecting processes, sockets, supervisors, ETS tables, and message queues is a built-in runtime capability — not a plugin or debug mode. Valim’s argument is that this should become the standard pattern: expose program state through safe, agent-accessible interfaces rather than human-oriented debugger UIs. The practical implication extends beyond development. Agents with runtime observability access can reach into production monitoring, identifying reliability issues and bottlenecks live.
There’s empirical support for this direction. A Tencent AutoCodeBench study testing 3,920 problems across 20 languages found Elixir had the highest AI coding agent completion rate at 97.5% — the best across all languages tested. Valim attributes this partly to the same qualities that make Erlang’s runtime introspectable: fast compilation, detailed error messages, low operational complexity, and the iterative feedback loop AI coding agents need to work effectively.
The Counter-Argument Valim Underplays
Valim’s thesis has a real gap that the Hacker News thread surfaces immediately: humans still review, maintain, and debug agent-generated code. Even if agents write 80% of lines, a senior engineer reading a pull request still cares whether code is readable, well-named, and logically structured. “Ergonomics don’t matter” isn’t true for the human in the review loop.
Moreover, the stronger-guarantees argument cuts both ways. Yes, explicit types help agents and compilers alike. However, Rust’s borrow checker, which provides strong static guarantees, is notoriously difficult for agents to satisfy correctly — precisely because its rules are complex enough to trip up both humans and models. Stronger guarantees don’t automatically mean better agent performance.
The more accurate frame is that language design now has two distinct users: the agent writing the code and the human reviewing it. Consequently, languages that optimize only for one will fall short. Valim’s argument points correctly at the direction of travel — runtime observability and queryable program state will matter more — but dismissing ergonomics entirely is the kind of overcorrection that makes good arguments easier to reject.
Key Takeaways
- Programming languages designed primarily around syntax sugar are optimizing for a shrinking use case as AI coding agents write more code
- Queryable program databases — SQL or Datalog interfaces over code intelligence — will serve agents better than position-based LSP queries; tools like Tidewave already demonstrate this pattern
- Runtime observability is the Erlang VM’s underappreciated advantage, and it is becoming a relevant differentiator for AI-driven development
- Humans still review agent-generated code, so ergonomics and readability don’t vanish — language teams now serve two users
- Elixir’s 97.5% AI completion rate, highest of 20 languages tested, provides empirical backing for Valim’s claim that guarantees and tooling matter more than syntax
