
AI on the web: opportunities, risks and the path to greater data control
8. July 2026Two hours to a prototype, three months to a standstill
A founder describes an app to her AI. Two hours later, a prototype with login, database and dashboard is up and running. Three months and a few hundred prompts later, every small change takes days, new features break old ones, and nobody can explain why the same data lives in three places. Neither can the AI.
This is not a failure of the AI. It is the limit of what Andrej Karpathy named “vibe coding” in early 2025: describe what you want and accept whatever comes back, without understanding the code.
My thesis: AI speeds up writing code, but not making architecture decisions. Confuse the two, and you gain weeks but lose months.
Where vibe coding ends
For quick prototypes, vibe coding is great. But once the software is meant to grow and last, its limits show:
- No memory. Every prompt is optimized on its own. Soon there are three different ways of handling errors, and nobody can answer the question “Why was it built this way?”
- No view of the whole. Dependencies grow without anyone choosing them.
- Invisible quality. Performance, security and data protection do not happen by accident.
- No accountability. A human is always liable for data breaches and outages.
The problem is not that an AI writes code. The problem is that nobody is in charge of the architecture.
The chain: from backlog to architecture increment
Agile development already provides every station. They only need to be complemented by deliberate architecture decisions before the AI writes code.

- Product backlog: make quality visible. Quality requirements such as response times, data protection or offline capability appear in the backlog as items of their own or as acceptance criteria. What is missing there, no AI will build.
- Refinement: flag architecture impact. Does the story need a new component, interface or dependency, or a change to the data model? A label is enough.
- Sprint planning: decide first, then build. Flagged stories only enter the sprint once the decision has been recorded as an ADR (see box). The AI provides options and the draft; the team decides. This is part of the definition of ready; open questions are settled beforehand with a short spike.
- Implementation: the AI works within guardrails. It gets ADRs, interface contracts (e.g. OpenAPI) and project conventions as fixed context. Tests come first, and tasks are small: not “build feature X”, but “implement this endpoint according to the contract”.
- Review and definition of done: check the architecture. Tools such as deptrac (PHP) or ArchUnit (Java) prevent forbidden dependencies, and humans review the structure. If the code deviates from the ADR, one of the two is deliberately adjusted.
- Delivery: every release is an architecture increment. From every story, a thread runs through ADR, code and test to the release. Feedback flows back into the backlog.
What has been mandatory in regulated industries such as automotive for years becomes relevant for everyone with AI: traceable architecture, with little effort, if you plan for it from the start.
In brief: Architecture Decision Records (ADR)
An ADR records exactly one architecture decision, usually on less than a page: title, status, context, decision, consequences. The format goes back to Michael Nygard (2011). ADRs are numbered Markdown files that live in the repository next to the code and are never deleted: if a decision changes, a new ADR supersedes the old one. They are worthwhile for decisions that affect several components or are hard to reverse.
# ADR-007: OpenAPI contract as the single interface definition
Status: accepted
Context: The Laravel backend and the Flutter app are developed in parallel,
mostly with AI support. Without a shared template, they drift apart.
Decision: Every interface is first described as an OpenAPI specification.
No endpoints without a contract.
Consequences:
+ Backend and app stay consistent; the AI has an unambiguous template.
- Every interface change costs an additional step.
In practice, the AI generates controllers, validation and tests in Laravel as well as models and the API client in Flutter from this contract. deptrac raises an alarm when a controller bypasses the service layer. The ADR thus becomes the project’s memory that the AI otherwise lacks: what is written in it, the AI can follow.
AI as a sparring partner in architecture design
AI does not make architecture decisions, but it makes them better:
- Generate options: two or three possible solutions, evaluated against the quality goals from the backlog rather than generic best practices.
- Attack the preferred solution: What happens under load, during a network outage or with an attacker? Which assumption is the shakiest?
- Check against earlier ADRs: the AI finds contradictions faster than any team member.
- Draft ADRs and checking rules: from the ADR draft to deptrac rules that enforce the decision automatically.
- Uncover erosion: regularly compare the actual code with the target architecture and keep diagrams as code up to date.
A proven prompt pattern: “Here are our quality goals and ADRs. Propose three options, evaluate each against these goals, name its biggest weakness and tell us what we do not need to decide today.”
The limit: the AI knows neither budget nor team nor strategy, tends towards common patterns and sounds convincing even when it is wrong. That is why the team decides – just better informed.
Who leads what?
Developers do not become redundant. Their work shifts from typing to deciding, reviewing and taking responsibility.
| Task | Who leads | How the other side helps |
|---|---|---|
| Architecture decisions | Team | AI drafts options, attacks them, checks against earlier ADRs |
| Interfaces and data model | Team | AI drafts contracts and models |
| Implementation and tests | AI | Humans slice the tasks and define the test cases |
| Code review | Human | AI checks conventions and errors beforehand |
| Responsibility and approval | Human | – |
For team leads: juniors still need tasks that teach them to understand architecture. Those who only wave things through unlearn how to judge.
What does this mean for you?
Introducing AI coding in your development team?
In a workshop, we set up the process from this article for your team: a backlog with quality goals, ADRs, context files and automated architecture checks.
Your data must not leave the building?
For counseling centers, practices, churches and non-profit organizations, I build AI applications with local models on your own hardware. I provide the technical solution; the legal assessment remains with your data protection officer.
How I work
I develop software myself and use AI consistently in the process. I lead the architecture deliberately: with ADRs, clear interfaces and automated checks. I also use AI-assisted code reviews for existing systems, for example to track down security vulnerabilities in WordPress and Joomla installations and their extensions. I bring my experience from quality and process work in regulated industries in a lean form. And I am honest about where AI helps and where it does not.
Conclusion: control makes speed sustainable
AI is an extremely fast developer without memory and without accountability. With a clearly led architecture as a guardrail, it multiplies the team’s impact – without multiplying the chaos. This does not require a heavyweight process: a few deliberate decisions per sprint, recorded and checked automatically. That way, the speed of the prototype is still there in the fifth release.


