DHH’s opening keynote at Rails World 2026 caused quite a stir. As the creator of Rails, he surprised many by announcing that HEY’s backend is being rewritten in Rust. His argument was that AI coding makes Rails less relevant: if agents write most of the code, developer friendliness matters less. It made me wonder how AI coding will affect the evolution of programming languages. Can new languages still gain traction in today’s world, especially if they aren’t specifically designed for AI?
New languages and new features in existing languages start with a significant disadvantage: there is simply less code using them for models to learn from. Even if a coding agent knows a feature and can use it correctly when asked, will it actually choose that feature on its own, or will it keep reaching for older and more common patterns?
I tested this with C++23 range features across different repository styles and agent instructions.
The result was clear: the agent knew the features, but rarely chose them without explicit guidance.
How I tested it
Whether an agent would use newer language features has a few different layers.
First, does it even know the features? And assuming it does will it choose them:
- without any guidance?
- if the codebase already uses similar modern features?
- if the project instructions ask to prefer modern features?
- if instructions explicitly mention the relevant feature set?
To test this, I used five C++23 range features: views::chunk, views::slide, views::zip, views::enumerate, and views::pairwise.
Before starting the experiment, I had a control run to make sure the agent actually knew and could use the features. I directly asked it to use each target feature and it used all correctly, so it was clear that the agent did know how to use these features.
For the repository setup, I created three versions of the same small C++23 project. They only differed in the style of the existing code:
- Neutral: only project setup.
- Legacy style: written in a legacy C++ style using loops and older standard library features.
- Modern style: written with modern C++ and ranges but without using the five features being tested.
I then gave the agent the same five tasks in each repository where each task targeting one of the features, but the prompt didn’t mention that feature or anything about ranges. The agents working on tasks were only aware of their task and corresponding repository.
I repeated those runs under three instruction setups: no project instruction, with an AGENTS.md asking for modern C++23 preference, and a more explicit version asking the agent to prefer range-based abstractions.
The codebase barely mattered
My first hypothesis was that the codebase would matter a lot. If a repository was already using modern C++ heavily, I expected the agent to be much more likely to prefer similar features than in a legacy codebase.
It turned out I was wrong. The codebase barely made a difference.
| Repository | Target feature used |
|---|---|
| Neutral | 0/5 |
| Legacy style | 0/5 |
| Modern style | 1/5 |
Without any guiding instructions, the agent chose the target modern feature only once across 15 runs. Even in the modern codebase, it usually preferred the more traditional implementation. The only exception was views::zip, which the agent used in the modern repository.
When I looked at the implementations, I noticed that in some runs the agent did pick up similar modern patterns from the codebase. But apparently the codebase alone was not encouraging enough to make it go fully modern.
Instructions changed everything
So next I wanted to see how much explicit guidance would change the result.
I added a short AGENTS.md asking the agent to write idiomatic modern C++23. Importantly, it did not mention ranges or any of the specific features I was testing.
The difference was much bigger than I expected.
| Repository | No instruction | Modern C++ guidance | Explicit ranges guidance |
|---|---|---|---|
| Neutral | 0/5 | 4/5 | 5/5 |
| Legacy style | 0/5 | 4/5 | 5/5 |
| Modern style | 1/5 | 5/5 | 5/5 |
| Total | 1/15 | 13/15 | 15/15 |
Without any instruction, the target feature was used in just 1 out of 15 runs. A generic instruction to prefer modern C++ pushed that to 13 out of 15.
What surprised me most was that even the legacy-style repository went from 0/5 to 4/5. It turns out the instruction has a much stronger impact on implementation than the style of the existing code.
Making the instruction more explicit pushed it to 15 out of 15.
Another interesting result was how the implementation changed depending on how explicit the guidance was.
Both were solving the same moving-window task, where views::slide was the target feature. With softer guidance, the agent kept the traditional O(n) monotonic-deque solution unless the codebase was already modern. With explicit ranges guidance, it switched to views::slide, which was shorter but O(n·w).
So maybe the takeaway here is that forcing a specific feature does not always make sense. Softer guidance seems more likely to make the agent consider modern features while still allowing them to choose a different better approach.
What does this mean?
My takeaway is that, as expected, coding agents are reluctant to use newer language features without some guidance. The more surprising part for me was that the surrounding codebase did not seem to count as strong enough guidance on its own.
I ran this experiment with modern C++23 features, but I would expect similar behavior in other languages and with other newer features as well.
So the bigger question still stands: how will new languages and language features gain traction in a world where more and more code is written by agents?