A format in the software-architektur.tv series places two elaborated architecture decisions side by side.One comes from humans, one from a generative AI.The guiding question is whether the author can be determined based on the result.The setup deliberately recalls the Turing test, which is about distinguishing machine from human expression.
For project managers, less interesting than the answer to this one question is what the question itself makes visible: architecture decisions are increasingly becoming a work step in which text generators can write along.
Why architecture decisions in particular are a good touchstone
In practice, an architecture decision is usually a document: it describes the context, the alternatives examined, the weighing of advantages and disadvantages and the choice made together with its consequences.This very structure is highly standardised - and therefore easily reproducible.
Language models are trained to produce plausible texts in familiar patterns.A clean comparison of monolith and service split, of relational database and document store, of synchronous and event-driven communication can be formulated formally flawlessly without the concrete project behind it having to be understood.
That is the actual core of the comparison: it is not the form that distinguishes a good architecture document from a weak one, but the anchoring in the actual situation.
Where generative AI is viable in design
For early concept work, text generators are a practical tool.They quickly provide a list of conceivable options, remind of quality characteristics that get lost in the heat of the moment, and put a first draft on paper that a team can work through.
Typical sensible uses:
- Collecting alternatives before a team commits to the first best solution
- Structuring decisions already made into a uniform format
- Formulating consequences and risks as a checklist for discussion
- Translating technical trade-offs into a language that management can also follow
In all these cases, the decision remains with the team.The AI provides material, not responsibility.
Where human experience cannot be replaced
Architecture is to a large extent context work.Decisive are factors that are rarely fully documented: the qualification of the team, grown legacy systems, operating models, budget limits, organisational responsibilities, regulatory requirements and the question of who will maintain the result in five years.
A generated document can only reflect these factors if they were described precisely beforehand.If they are missing, a text emerges that sounds correct and still misses reality.This kind of error is particularly insidious because it does not stand out in form - which is exactly the point of a Turing test format.
Added to this is commitment.An architecture decision is also a promise to the client, operations and the team.Whoever makes it bears the consequences.This part cannot be delegated.
What this means for review processes
If generated and human drafts resemble each other in the result, the question of origin loses weight.The question of review becomes more important.A robust review process primarily addresses the points where generated texts typically remain thin:
- Context check: Do the stated boundary conditions match the real project - team size, operating environment, existing systems?
- Alternatives check: Were the discarded options really evaluated or merely mentioned?
- Consequences check: Are follow-up costs, migration effort and operating effort quantified concretely or do they remain general?
- Evidence check: Can central assumptions be substantiated, for example by measured values, load tests or experience from the existing system?
- Responsibility: Who signs off on the decision by name, and when will it be reviewed again?
It also makes sense to note the use of generative tools transparently in the document.Not as a vote of no confidence, but so that later readers know which parts are based on measured experience and which on a design proposal.
Concept work becomes faster, not easier
The most noticeable effect of generative tools lies in the speed of the first draft.What used to cost half a day of writing work is available in minutes.The time freed up should not be booked as a saving but invested in review.
Because the costs of a wrong architecture decision arise not in writing but in implementation and operation.A quickly generated but unreviewed draft merely shifts the effort to later - to where corrections are expensive.
Classification for web and software projects
For projects this means: generative AI can be used sensibly in the concept phase, for example to collect options and document decisions uniformly, but it does not replace expert review by people who know the system and its context.Define who is responsible for an architecture decision, by which criteria it is reviewed and when it comes up again.Where these rules are stated, the question of a document's authorship is secondary - what remains decisive is whether the decision fits the specific project.
Sources
- software-architektur.tv: The Architecture Turing Test — heise developer News