The software-architektur.tv format is dedicating an episode to the question of how software must be built in the age of generative AI. The guest is Randy Shoup in conversation with Ralf D. Müller. As far as content is concerned, only the announcement is available so far – but the occasion is well suited to sorting out a question that is currently on the table in many projects: What actually changes when development teams work with AI assistance, and what remains unchanged?

The bottleneck shifts

When code generation becomes faster, the effort does not disappear, it migrates. It migrates into the decision about which building blocks should be created in the first place, how they are connected and how one later recognises whether the whole thing still works. That is precisely architecture work – and it is difficult to delegate because it weighs business interrelationships, operational reality and budget against one another.

In practice this means: teams that already had clean boundaries benefit noticeably. Teams whose systems have grown historically and are poorly documented produce, with assistance, above all more of the same, faster. The tools amplify the existing structure, they do not replace it.

Review becomes more important, not less

In code review – the systematic examination of changes by a second person – the character of the work changes. Classically, one primarily checks whether someone has made a thinking error. With generated code, a second question is added: Is this solution actually the right one for this system, or is it merely a plausible standard solution from a different context?

Generated code typically looks good. It is consistently formatted, names things comprehensibly and often contains comments. This makes review more difficult because the superficial signals of quality are no longer distinctive. Check questions that target the context are therefore useful:

  • Does the change use existing building blocks of the project, or does it build a parallel solution alongside them?
  • Are error cases, permissions and limits actually handled or merely mentioned?
  • Does the cut fit the existing module boundaries?
  • Do tests exist that check the business core – and not merely confirm the generated implementation?

The last point is delicate. If implementation and test come from the same source, they may be checking the same mistaken assumption. Tests retain their value above all when they are derived from the business requirement.

Responsibility remains with people

For clients, this is the central point: liability for a system, its data processing and its security cannot be handed over to a tool. Whoever approves a change is responsible for it – regardless of who or what wrote the first draft. This leads to a simple rule: nothing goes into production that no one on the team can explain.

This has consequences for project planning. If creating a feature is faster but understanding and checking it take just as long, the overall duration decreases less than hoped. The more realistic assumption is that the share of time for conception, review and testing in the total effort increases.

What structure pays off now

Some principles are not superseded by AI assistance but become more important:

  • Clear boundaries between modules. They give both people and tools a manageable context.
  • Automated checks in the pipeline. Static analysis, dependency and licence checks as well as security scans scale with the amount of code; manual visual inspection does not.
  • Documented decisions. Short notes about why a solution was chosen are the only source from which intent can be reconstructed.
  • Observability in operation. Logging and metrics show whether a change behaves as intended under real load.

In addition, there are organisational questions that should be clarified early: which tools may be used, which data may leave the company in the process, and how the origin of code is documented? These points belong in contracts and in the definition of done, i.e. in the binding list of what allows a task to be considered complete.

Not a tool question, but a maturity question

The benefit of generative tools correlates less with the chosen model than with the maturity of the development environment around it. A project with reproducible builds, meaningful tests and a functioning review process can accept or reject suggestions swiftly. A project without these foundations loses control over its own codebase faster than before.

For web and software projects, this means: investments in test strategy, deployment automation and documented architecture decisions now pay off twice – they secure maintainability and they are what makes AI assistance productively usable in the first place. Anyone evaluating an offer should therefore ask less about which assistance tools are used and more about how review, tests and handover are regulated.

The speed of individual work steps rarely decides the success of a project; the question of whether the system can still be changed in three years, on the other hand, almost always does.

Sources