A report from the developer community is currently sparking discussion: the creator of the Ruby on Rails web framework is having the backend of his product HEY written in Rust by AI agents. What is remarkable about this is less the choice of language itself than the reasoning that resonates in the technical debate – if agents generate the majority of the code, the question of the programming language loses weight. What matters is what can be verified in the result.

For companies that are gradually converting their development processes to AI tools, this is more than a side note. It touches on a decision that is traditionally made early and with great weight in projects: the choice of technology stack.

Why the choice of language has weighed so heavily until now

The decision for a programming language was always also a personnel decision. Whoever chose PHP tied themselves to a labour market, to libraries, to conventions and to what a team can master safely in a reasonable time. Languages with a steep learning curve – Rust is considered a classic example – were therefore regarded as a risk in many projects, even if they would have been a good technical fit.

A second factor was writing speed. Frameworks like Rails became popular because they enabled rapid progress. Expressive, compact languages had a tangible economic advantage as long as people typed every line themselves.

It is precisely these two arguments that lose force when an agent generates the code. The learning curve of a language is not an obstacle for a model in the sense that it is for a team. And the time that writing costs carries different weight when writing is no longer the bottleneck.

The bottleneck shifts to control

What remains is the question: how do I know that the generated code is correct? This question was always there, it was just behind others. When an experienced person writes line by line, trust arises along the way – through thinking while writing, through code reviews, through the team's experience. If this process falls away or is greatly accelerated, trust must come from other sources.

This brings properties to the fore that were previously regarded more as secondary topics:

  • Strict type systems and compilers that catch an entire class of errors before code even runs.
  • Automated tests that are not only present but cover what is functionally essential.
  • Deterministic builds and tools that deliver the same result for the same input and thus remain traceable.
  • Clear architectural boundaries so that a change only takes effect where it should.

In this reading, choosing a language with a strict compiler is no longer a luxury but a control instrument. What the machine can check no longer has to be read by a human.

What decision-makers can take from this

No general rule can be derived from a single prominent case. An established product with an experienced team is a different starting point from a mid-sized project with a grown system landscape. Nevertheless, the underlying questions are transferable.

Anyone who seriously wants to introduce AI-supported development should first check how well their own codebase can be verified at all. A project without reliable test coverage benefits significantly less from agents – there, rapidly generated code above all increases risk, because no one can determine in good time whether something has broken. The sensible order is therefore: first establish verifiability, then increase generation speed.

The requirements profile within the team shifts as well. What is needed is less the ability to write a particular syntax fluently than the ability to formulate requirements precisely, make architectural decisions and critically assess results. Review competence becomes more important than typing speed.

Where caution remains appropriate

The thesis that languages are losing weight has limits. A technology stack is also a commitment to an ecosystem: to libraries, hosting, security updates, to the question of who will maintain the system in five years. These aspects do not disappear just because an agent delivers the first draft. Maintainability is not purely a writing problem.

In addition: even the best compiler only checks technical correctness, not functional accuracy. Whether a discount model, an authorisation logic or a billing run does what the business needs is still decided by the functional specification – and the tests derived from it.

Assessment for web and software projects

For projects in the web and TYPO3 environment, this above all means: investments in test coverage, clean interfaces and reproducible deployments pay off twice, because they simultaneously form the basis for meaningful AI use. The choice of technology should in future be judged more by how well results can be automatically safeguarded, and not solely by how familiar a language is within the team. And regardless of who or what writes the code, responsibility for architecture, security and functional accuracy remains with the people in the project.

Sources