An current episode of the software-architektur.tv format is devoted to a question that is currently left unresolved in many development teams: AI writes code – but the architecture must hold up. The discussion covers where new points of friction arise and who ultimately bears the responsibility. The title deliberately sets a counterpoint to the widespread expectation that tools should above all remove resistance: here, friction is understood as a feature, not a defect.

This sharpening is worth a closer look, because it touches the core of what currently occupies software projects in mid-sized companies. Code generation is quickly available. Sustainable structures are not.

Why speed shifts the actual question

When an assistant designs a module, an interface or a test suite within minutes, the bottleneck shifts. It is no longer the writing of code that costs the most time, but the understanding, checking and assessing of what has been created.

Architecture is the sum of the decisions that can later only be revised at great cost: intersections between modules, data sovereignty, dependencies on third-party libraries, contracts between systems. Such determinations often arise incidentally in generated code – as a side effect of a suggestion that looks plausible in itself.

The result is a familiar pattern at new speed: locally correct code that erodes structures in the overall picture. Anyone who accepts many such decisions unnoticed builds up technical debt faster than it becomes visible.

Friction as a deliberately set control point

Friction has a bad reputation in software development. It is regarded as a sign of poor tools, cumbersome processes or too many approval loops. In an environment in which suggestions arise at almost no cost, however, this relationship is reversed.

A review that costs time is not a brake block, but the moment in which someone takes responsibility. An architecture decision that must be documented and justified forces engagement with alternatives. A test run that fails provides information that a quickly nodded-through merge would not have provided.

It therefore makes sense to distinguish between two kinds of resistance:

  • Unproductive friction arises from manual routines, unclear responsibilities, missing environments or waiting times without gain in insight. It should be reduced.
  • Productive friction arises where a decision must be explicitly made and owned. It should be preserved – and, at high generation speed, rather strengthened.

The art lies in keeping the two apart. Tools that sweep away every hurdle across the board usually also hit the second category.

Responsibility cannot be delegated to a model

A language model provides a suggestion. It is not liable for data protection violations, bears no contractual penalty in the event of outages and explains to no one why a release has to be postponed. Responsibility remains where it was before: with the team, with the technical leadership, with the client.

In practice this means: every line that enters a repository needs a person who has understood it and can stand behind it. The origin of the draft changes nothing about this. Anyone who treats code review as a formality because the suggestion "comes from the AI" shifts risk into operations – to where it becomes most expensive.

What teams should specifically safeguard

From our project practice, a number of starting points emerge that hold regardless of the assistant used:

  1. Architecture framework before tool use. Layering, module boundaries and permitted dependencies should be laid down in writing before generated code is produced on a larger scale.
  2. Document decisions. Short notes on essential determinations, together with justification and rejected alternatives, keep knowledge in the team, even when people change.
  3. Automated counter-checks. Static analysis, dependency checks, tests and security scans detect structural breaks earlier than any manual reading.
  4. Review with clear responsibility. One named person responsible per change, no blanket approvals.
  5. Clarify licensing and data protection questions. Which content may be transmitted to which service, and under what conditions may resulting code be used?

None of these points is new. What is new is the volume pressure under which they stand. Processes that worked with twenty changes per week reach their limits at three times that number.

For clients: speed is not a quality feature

In proposal discussions, speed is currently readily put forward as an argument. However, it is only an advantage if the solution remains maintainable afterwards – that is, if another team can extend it in two years without rewriting it.

Sensible questions to a service provider are therefore less "How fast?" and more: How are architecture decisions made and recorded? Which automated checks run before every release? Who reviews generated code, and with what time budget? How is it ensured that internal data does not flow unintentionally to external services?

Answers to these questions say more about later operational stability than any statement about development duration.

Assessment

For web and software projects, the focus is shifting: the actual value in future lies less in generating code than in defining and enforcing sustainable structures.

Anyone deploying assistants should simultaneously invest in architecture work, automated checks and clear review responsibility – otherwise saved development time will later be repaid in maintenance.Deliberately placed control points are not a step backwards in this environment, but the prerequisite for speed to remain usable at all.

Sources