In a current episode of a specialist format on the topic of software testing, Richard Seidl and Dr Benjamin Hummel discuss which tasks and which responsibility remain for developers when code is generated by AI. The pointed question is whether, in the end, only reading is left. It hits on a point that has long been noticeable in projects: the bottleneck is shifting from production to review.

The effort moves, it does not disappear

AI assistants generate large amounts of code in a short time. This shortens the phase in which lines come into being — and lengthens the phase in which someone has to assess whether these lines do the right thing. Anyone who has written a function themselves knows the assumptions behind it. Anyone who is presented with it must first reconstruct those assumptions.

This is not a new discipline. Code review, i.e. the examination of changes by a second person, has been part of the craft for years. What is new is the ratio: in the past, review was the control of a manageable increase, today it can become the main share of working time. Anyone planning for speed gains should plan for this share as well — otherwise speed in design is eaten up by rework in integration.

Reading is not a lesser activity

Generated code often looks plausible. It follows common patterns, is formatted and commented. That is precisely what makes review harder, because superficial signals of quality are missing that one would previously have latched onto. The relevant questions lie deeper:

  • Does the implementation solve the actual requirement or only the literally formulated task?
  • Which edge cases are handled, which are silently ignored?
  • Does the solution fit the existing architecture or does it establish a second pattern for the same problem?
  • Are data validated correctly, permissions checked, errors handled cleanly?
  • Do new dependencies arise that must be maintained and updated?

This assessment requires experience. One can only review what one could have designed oneself. This argues for deploying not less but more targeted senior expertise in AI-supported projects — as a counterweight to the volume.

Tests as the more robust judgement

Reviews are samples taken by humans and are therefore dependent on daily form and time pressure. Automated tests are the repeatable counterpart. They describe what a system should achieve and trigger when a change breaks that promise. In an environment in which changes arrive faster and in larger blocks, their value increases.

The direction of view is important. Tests that arise after the generated code easily reflect only what the code does anyway — including the errors. Tests derived from the requirement, by contrast, check the desired behaviour. It is therefore worth formulating functional acceptance criteria before implementation, in a language that business departments also understand.

Equally important is that high test numbers are not confused with certainty. A metric such as test coverage — the proportion of code executed during test runs — says something about reach, not about relevance. What is decisive is whether the critical paths are covered: payment, login, data migration, interfaces to third-party systems.

Responsibility remains with people

For clients, the organisational side is as important as the technical one. An assistance system bears no responsibility; it lies with those who approve and operate the code. This allocation should not remain implicit.

In practice, this means clarifying a few points in the project setup: Who approves changes, and may that be the same person who formulated the prompt? Which areas of the system are so sensitive that generated contributions must be particularly reviewed or excluded there? How is it documented that a change was reviewed? Which rules apply to licences and to the handling of internal data in prompts? And which automated checks must pass before a human reads anything at all?

What changes in day-to-day project work

A sensible order is one in which machines handle the mechanical and humans retain the judgement. Static analysis, formatting rules, dependency and security checks as well as the test suite run automatically in the build pipeline. Only then does the functional review begin — and this concentrates on architecture, edge cases and traceability.

It is also helpful to keep changes small. Large generated blocks are hard to assess and are waved through when in doubt. Small, clearly delimited packages can be reviewed, tested and rolled back in the event of an error.

Assessment

For web and software projects, this means a shifted cost structure: what is saved in writing must partly be invested in review, tests and tools — the net gain only arises once this structure is in place. Anyone comparing offers should therefore not only ask about speed, but about the review process, test coverage of critical processes and clear approval responsibilities. The most robust promise in AI-supported projects is not how quickly code is created, but how reliably what goes into operation is reviewed.

Sources