Since AI assistants have been used more widely in software development, a topic that was long regarded as a tiresome duty has moved to the fore: documentation.In an interview about the Continuous Architecture approach – an approach that understands architecture work as an ongoing activity rather than a one-off planning phase – Murat Erder describes how AI can change development without overriding the fundamental principles of good architecture.The practical core lies precisely in this combination: the tools change, the requirements for structure and traceability remain.

For companies that operate or commission software, this is a surprisingly tangible statement.After all, it shifts the question away from "Which model do we use?" to "How well is our project actually described?".

Why context becomes the limiting factor

AI assistants generate suggestions based on what they see: source code, configurations, comments, tickets, architecture descriptions.This material forms the context.If it is incomplete or contradictory, suggestions arise that appear formally plausible but do not fit the actual system.

Many teams know the typical patterns from everyday work:

  • An architecture diagram shows a service that was replaced long ago.
  • A README describes a setup that has not worked for two releases.
  • Conventions for naming or error handling exist – but only in the heads of two people.

Such gaps have always been expensive, but they mainly came to light during the onboarding of new team members.With AI support, the same effect becomes an everyday occurrence: the tool adopts the outdated assumptions and reproduces them in new places in the code.

Documentation is no longer an end in itself

Until now, documentation was often an investment with a diffuse return.It paid off during staff changes, audits, and handovers to a new service provider – that is, rarely and difficult to measure.This changes when documentation becomes the input for a tool that is in daily use.

In practice, this means: a concise but up-to-date overview of system boundaries, data flows and deliberate decisions has a direct effect on the quality of the suggestions.Conversely, every page that is not maintained becomes a source of interference.So anyone who tidies up is no longer doing it for a hypothetical successor, but for the next working day.

An honest reduction helps here.Better ten pages that are accurate than eighty pages of which nobody knows which ones still apply.Documentation that nobody is responsible for should either be given an owner or removed.

Architecture principles remain the benchmark

The second half of the statement is just as important: AI does not override good architecture.Clear responsibilities between components, clean interfaces, deliberate decisions about dependencies – all of this remains necessary, regardless of who or what writes the code.

Rather, the effect is reinforced in both directions.In a well-cut system, changes can be kept local, tests are reliable, and an assistant can work within clear boundaries.In an entangled system without recognisable structure, the same tool mainly accelerates the creation of further entanglements.

That is why the order is decisive: first structure and description, then speed.Doing it the other way round increases the throughput of code, not the value of the software.

What teams can do concretely

A clean-up project does not have to be big.A step-by-step approach that fits into existing workflows makes sense:

  1. Stocktaking: Which documents exist, who last touched them, which are still valid?Everything unclear goes on a list.
  2. Record decisions: Short notes on central architecture decisions – what was chosen, which alternatives existed, why the choice fell that way.
  3. Proximity to the code: Store descriptions where they are noticed in everyday work, ideally in the repository rather than in a filing system that is rarely opened.
  4. Build maintenance into the process: Documentation changes belong in the same change as the code and are reviewed along with it.
  5. Make conventions explicit: Naming, error handling, test strategy – as text, not as oral tradition.

The effort for this is manageable, especially compared with the follow-up costs of false assumptions that spread through the system over months.

Classification for projects and budgets

For decision-makers, the argument thus shifts.Expenditure on documentation and architecture work can no longer be justified solely by risk prevention, but by development speed and code quality in ongoing operations.Anyone who wants to introduce an AI-supported way of working should budget for this before buying licences for tools.

The point also gains weight in tenders and service provider changes.A system that is cleanly described can be taken over faster, estimated more realistically and developed further with lower risk – with or without AI support.

What this means for web and software projects

In web and TYPO3 projects, the decisive question in future will be less whether a team uses AI tools, but how well the project is described for such tools.Up-to-date architecture overviews, documented decisions and binding conventions thus become a direct productivity factor, not a downstream diligence task.Anyone who invests in order now simultaneously improves maintainability, handover capability and the yield from every further automation step.

Sources