AI assistants have changed software development in a clearly measurable way: the path from requirement to first working code has become shorter. A recent study reported by the industry service DataCenter-Insider points to the downside: quality assurance – i.e. reviews, tests and sign-offs – often cannot keep pace with this speed. This creates risks for companies.

This is less a statement about the quality of generated lines of code than about processes. If one sub-step in the development chain becomes significantly faster while all others remain unchanged, the bottleneck shifts. It does not disappear.

Why testing becomes the bottleneck

Code generation can be automated well because it has a clearly defined outcome. Quality assurance, by contrast, is distributed work: it consists of business sign-offs, code reviews by colleagues, automated tests, manual checks in various browsers and approvals by business departments.

These steps depend on people, on schedules and on existing test infrastructure. They do not scale just because an assistant delivers suggestions faster. Typical patterns that arise from this:

  • Review backlogs: More changes are awaiting review than the team can examine in reasonable depth.
  • Superficial review: If reviews are still carried out within the same time window, the depth of control per change decreases.
  • Deferred troubleshooting: What goes unnoticed in review shows up later – in acceptance, in operation or with the customer. There, correction is more expensive.

The trust problem with generated code

A second point comes on top. Code written by a human implicitly carries a rationale: the author can explain why a solution looks the way it does and not otherwise. With generated code, this knowledge is missing in the team if nobody has really worked through the output.

The code may then work in the normal case – but nobody can reliably say how it behaves with faulty input, under load or when the underlying library is updated. These are precisely the questions that quality assurance normally answers.

Consequences for web and TYPO3 projects

In web projects this has a particularly immediate effect because the applications are publicly accessible. An error in an internal tool is noticed within the department. An error in a form on the company website is noticed by prospects, or it leads to data being processed incorrectly, incompletely or without protection.

The relevant areas are above all:

  • Data processing in forms: validation, storage, email sending, data protection-relevant paths.
  • Permissions and access: who may see and change which content in the content management system? Such rules are quickly formulated and rarely fully tested.
  • Extensions and updates: custom developments must survive version changes of the system. Without tests, incompatibilities are only noticed at update time.
  • Output and accessibility: generated frontend markup is not automatically semantically clean or accessible.

What can be followed up organisationally

The obvious answer is not to scale back AI support, but to treat the review side with the same consistency as the creation side. Several starting points lend themselves to this.

Automated tests as part of the definition of done. If every change includes tests, the test base grows at the same pace as the code. Tests can in turn be designed with AI support – although the same caveat applies here: a test that nobody has read may be checking the wrong assumption.

Prioritise reviews instead of distributing them evenly. Not every change needs the same review depth. It makes sense to define risk areas – authentication, payment processes, personal data, interfaces – and to review them more intensively as a mandatory rule.

Automated pipelines. Static code analysis, dependency checks and test runs on every commit catch some of the standard errors without tying up staff time. This does not replace review, but it relieves it.

Ensure traceability. It helps to record within the team where work was done with which support. Not as a control measure, but so that later troubleshooting knows where context knowledge might be missing.

The budget side

For decisions, one point is central: the time gains of code generation are visible and are realised early in the project. The costs of inadequate quality assurance arise later and appear in other budgets – in support, maintenance, rework or in downtime.

Anyone who plans for the savings on one side without co-funding the review side shifts effort into the future instead of reducing it. In proposals and project plans, the test share should therefore be recognisable as a separate item, not as a residual amount.

Assessment

For web and software projects, this shifts the real lever: the gain lies not in more generated code, but in a review chain that is equal to this output. Anyone who anchors test automation, clear review rules and defined risk areas early in the project can actually use the speed.Anyone who introduces them later pays the difference in operation.

Sources