On 27 August 2026, heise developer announced an edition of the software-architektur.tv format in which Ralf D. Müller talks to Kevlin Henney. The topic: how does generative AI – i.e. models that generate text and source code on request – affect software development, and to what extent do understanding and testing gain importance in the process?

The question hits a sore point in many ongoing projects. The bottleneck in development was rarely the typing. It lay in understanding what already exists, in agreeing requirements and in safeguarding changes. These very proportions do not become smaller through AI assistance – on the contrary.

What shifts when code becomes cheaper

When generating code costs less time, more code is produced per unit of time. This also increases the amount of material that someone has to read, assess and take responsibility for. The effort therefore does not disappear, it merely moves to another point in the process.

Three effects can be observed in practice without needing to consult large studies:

  • Review becomes a bottleneck. A pull request – i.e. a change proposal that is reviewed before merging – can be generated in minutes, but cannot be seriously thought through in minutes.
  • Plausible is not correct. Generated code usually looks good. It follows familiar patterns, uses common libraries and compiles. Whether it reflects the business rule discussed in the customer meeting is another matter.
  • Knowledge remains in the team less often. Anyone who has thought through a solution themselves can explain it two years later. Anyone who has adopted it without fully grasping it may not be able to.

The mirror idea

The phrase "AI as a mirror" in the title of the broadcast points to a second aspect: models reflect back what is presented to them. An unclear requirement leads to a solution that adopts the ambiguity and gives it a clean surface. A codebase without structure provides context without structure.

For project managers, this is less a technical than an organisational insight. Tools that deliver results quickly do not make gaps in requirements clarification more visible, but initially more invisible – because previously a tough implementation process served as an early warning system. If a developer asked questions after three days, that was a signal. If this friction falls away, the signal is also missing.

Why testing moves to the fore again

In this constellation, tests are more than quality assurance. They are the most precise form in which an expectation of software can be expressed. A test describes what should hold true – regardless of who or what wrote the implementation.

This changes the order of priorities. Where robust test coverage exists, AI-generated code is comparatively uncritical: errors come to light, changes are reversible. Where it is missing, every additional line of code becomes a piece of unchecked assumption.

In practice, this means: investments in test infrastructure, in automated pipelines and in meaningful test cases pay off more strongly now than two years ago. Not because AI would be particularly unreliable, but because the ratio of generated to reviewed code can get out of balance.

What this means for teamwork

The distribution of roles is also changing. When less time is spent on writing, the ability to read other people's code, to justify architectural decisions and to sharpen requirements becomes more important. These are competencies that cannot easily be shortcut and that usually develop over years.

At the same time, the question arises as to how career starters can still gain this experience when the routine tasks through which it is classically acquired are handed over to a tool. There is currently no universally valid answer to this; however, it is worth consciously raising the question in your own team instead of letting the choice of tools answer it for you.

Concrete starting points

Anyone who wants to use AI assistance productively without building up technical debt can start at several points:

  1. Plan review capacity. If generation becomes faster, review must grow along with it – in terms of staff and time.
  2. Demand traceability. Anyone who submits a change proposal should be able to explain it, regardless of how it came about.
  3. Test coverage before acceleration. In areas without automated tests, build up the safeguards first, then increase the pace.
  4. Sharpen requirements. The more precise the business specification, the less room for interpretation arises – among people as well as models.
  5. Make maintainability measurable. Metrics such as the lead time of changes or the error rate after deployment show whether the acceleration holds up or merely shifts things.

Assessment

For web and software projects, this means above all one thing: the benefit of generative AI is not decided by the volume of generated code, but by an organisation's ability to understand and safeguard this code. A TYPO3 project or a custom business application lives for five to ten years – in this period, it is not the speed of the first implementation that is decisive, but how expensive the twentieth change becomes.

Anyone who invests today in tests, review discipline and clean requirements clarification creates the prerequisite for using AI tools later without any worries.

Sources