Two reports from the same day together paint an illuminating picture. On the one hand, AI agents have translated the TypeScript compiler into Rust; the resulting project tsrs is being taken over by Cloudflare. On the other hand, an episode of the software-architektur.tv format with Alexander von Zitzewitz and Ralf D. Müller is devoted to the question of what role clean software architecture still plays at all in the age of AI.

At first glance, the two topics seem unrelated. In fact, they describe the same development from two directions: machine code generation has now reached an order of magnitude that until recently was considered unrealistic – and precisely for that reason, the work of development teams is shifting towards structure, architecture and review processes.

What the Rust port actually shows

A compiler is a program that translates source code into another form – in the case of TypeScript, into executable JavaScript. Such software is among the most demanding categories of all: the behaviour is specified down to the last detail, there are extensive test suites, and any deviation is immediately noticeable.

That AI agents transfer such a codebase into another programming language is remarkable – though for a different reason than is often assumed. A port is not a greenfield development. The target behaviour is fully available, the structure already exists, and machine-generated results can be checked against the existing implementation. The task is precisely delineated. It is precisely this delineation that is the prerequisite for automated generation to work on this scale.

Another detail is interesting: Microsoft is already using some of the optimisations discovered during the port for TypeScript 7.1. So the process did not just translate, but produced insights into the original implementation that flow back into the original. The fact that Cloudflare is taking over the project also shows: even generated code ultimately needs an organisation that maintains it, takes responsibility for it and develops it further.

The question behind the discussion

The debate that software-architektur.tv is devoted to thus strikes a nerve. When code is produced quickly and in large quantities, it is tempting to think that structure is secondary – what can be regenerated does not need to be carefully cut.

Practice suggests the opposite. The more code is produced by machine, the more important three things become:

  • Clear boundaries between components. Only when responsibilities are cleanly separated can one part be replaced without endangering the rest – regardless of who or what replaces it.
  • Verifiable behaviour. Tests and specifications are the only reliable basis for assessing generated results. Without them, only trust remains, and trust is not an acceptance criterion.
  • Traceable decisions. Why a solution is built this way and not another is not written in the code. This justification remains a human task.

Review becomes the bottleneck

When the generation of code becomes faster, the bottleneck shifts. It is no longer the writing that costs the most time, but the understanding, checking and contextualising of the result. A review in which several thousand lines of generated code are presented at once is something different from reviewing a manageable contribution.

Architecture is the tool here that makes verifiability possible in the first place. A well-cut system allows changes to be assessed locally. An intertwined system forces you to keep the whole in mind with every change – a requirement that simply can no longer be met as throughput increases.

What this means for projects in mid-sized companies

Very few companies port compilers. But the mechanics are the same as soon as AI tools are used in daily development – and that is already happening widely.

In practical terms, a few guidelines can be derived from this:

  1. Before using generative tools, it should be clear what a result can be measured against. If automated tests are missing, the safety net is missing.
  2. Responsibilities in the code should be cut in such a way that individual areas can be revised independently.
  3. Review capacity must be planned for. Anyone who accelerates generation but does not scale up checking accordingly shifts risk into the future.
  4. Responsibility remains organisational: it needs named individuals who stand behind a code area – regardless of how it came about.

Assessment

For web and software projects, the focus of the work shifts, not its standards. The more code is produced by machine, the more the quality of architecture, tests and review processes determines whether speed actually turns into value or merely lets technical debt grow faster. Anyone who invests today in clear structures and reliable acceptance criteria simultaneously creates the basis for using AI tools productively and in a controlled way.

Sources