Agentic engineering – that is, software development in which AI agents work through multi-step tasks largely independently instead of merely suggesting individual lines of code – still sounds like an experiment to many. In the practice of large development organisations, it no longer is. At SAP, the use of such tools is part of everyday work; Oliver Nocon and Lukas Heimann report on the experience gained from it. The core statement of their report is uncomfortable: AI makes teams faster – unfortunately also with bad processes.

The amplifier effect

This observation deserves more attention than any discussion about model sizes or token prices. Because it describes AI not as a solution, but as a multiplier. Where requirements are clearly formulated, tests are robust and reviews are binding, an agent increases throughput. Where requirements remain vague, test coverage has gaps and code reviews are more of a formality, the same agent increases throughput just as much – only then it produces more of what was already wrong.

The difference from earlier productivity promises lies in the pace. A team that produces three questionable pull requests per week without AI has time to notice the mistake. A team that produces thirty does not have that time. Technical debt does not arise more slowly because a machine writes it – it arises faster.

The bottleneck moves

When code generation becomes cheaper, the bottleneck shifts. It then no longer lies in writing, but in reviewing, understanding and taking responsibility. That is precisely where many organisations are weakest, because review work is rarely visibly planned and even more rarely rewarded.

In practice, this means: anyone who uses agents needs more review capacity, not less. And they need reviews that actually take place in substance – not as a click on an approval button under a set of changes that no one can read in a reasonable amount of time anymore. Large, machine-generated changes are particularly unwieldy for human review because they look superficially plausible and the actual problems lie in edge cases, error handling or implicit assumptions.

What should come before introduction

This logic yields an unspectacular but effective order: first the processes, then the tools. Before AI coding workflows are anchored in a team, a few points should be clarified:

  • Definition of Done: How is it determined that a task is finished – and verifiably so, not by gut feeling?
  • Automated quality assurance: Tests, static analysis and the build pipeline must run reliably and be meaningful. An agent working against a green but empty test suite optimises for the wrong goal.
  • Binding reviews: Clear responsibility, realistic upper size limits for changes, documented reasons for rejection.
  • Architecture and code conventions: What is not set down in writing cannot be followed by an agent – it will then invent its own variant.
  • Accountability: Who is professionally liable for code that an agent has generated? The answer must not be "the tool".

Process quality becomes measurably expensive

The economic side effect is interesting. Weak processes have so far been primarily an annoyance that expressed itself over months in delays and rework – diffuse and hard to attribute. With high change velocity, they become an immediately noticeable cost factor. That is unpleasant, but also an opportunity: organisations that previously saw no reason to clean up their development processes now get a very concrete one.

For decision-makers, this results in a different question than the usual one. Not "which AI tool do we procure?", but: can our processes withstand a doubling of change volume? If the honest answer is no, then the introduction of agents is not progress, but an acceleration in the wrong direction.

Step by step instead of across the board

Experience has shown that a narrow scope at the beginning works well: one team, one clearly delimited area of the codebase, a manageable class of tasks. There it can be observed where friction arises – usually not in code generation itself, but at the handover points: unclear tickets, missing test data, undecided architecture questions, dependencies on other teams.

Fixing these points of friction is the actual work. It pays off regardless of which model is current next year, and it is the reason why the report from everyday corporate life is more than an anecdote: it describes not a tool question, but an organisational question.

What this means for projects

For web and software projects, this means reordering priorities: anyone who wants to introduce AI-supported development invests first in test coverage, review discipline and clear requirements – not in licences. Only then does speed also become quality, instead of just more volume. And in tenders and the selection of service providers, it is worth asking less about the AI tools used than about how a team checks and takes responsibility for its results.

Sources