Prompt-driven development, often called vibe coding, describes a working mode in which code is created predominantly from natural-language instructions to an AI model.The result is quickly visible: a function, a form, an endpoint.What does not automatically grow alongside it is the understanding of the system in which this code must later live.

This is precisely where a current discussion from the testing community comes in.Richard Seidl talks with Marc Bless and Thomas Ronzon about the fact that the middle tier of developers is disappearing – that is, the experience level between entry-level and specialist – and that this does not remain without consequences for practice.

Why the middle experience level is so important

In projects, this group traditionally takes on tasks that are rarely in the offer but decide maintainability: reading and assessing code, explaining connections between modules, cutting test cases sensibly, reviews with justification instead of gut feeling.At the same time, it is the link through which knowledge passes from experienced architects to new team members.

If this layer becomes thinner, a gap arises that tools only seemingly close.A model can generate a class, but it does not know the silent rules of a grown system: which component is historically regarded as a single point of failure, which database table other business units also use, which change disrupts an interface to a third-party system.

The typical risks in projects

From practice, several patterns can be described that occur with purely prompt-driven work:

  • Locally correct, globally wrong: The generated code fulfils the requirement in the excerpt but violates conventions or responsibilities of the overall architecture.
  • Redundancy instead of reuse: Functions are newly generated although they already exist in the project – often slightly different, which multiplies maintenance effort.
  • Tests as an add-on: If tests are also generated, they may well check exactly what the code does, not what is required from a business perspective.
  • Unclear responsibility: No one in the team can fully explain the code.In the event of disruptions, the time to the cause increases considerably.
  • Security and data protection issues: Permissions, input validation and logging are topics that rarely emerge completely from a short prompt.

None of these risks is new.What is new is the speed at which they can accumulate because the generation of code has become considerably cheaper than its understanding.

What makes AI speed reliable

The answer does not lie in banishing AI support from projects.It lies in strengthening the checkpoints that were previously covered informally by experience.Four building blocks have proven themselves:

  1. Document architecture decisions: A few pages that record which layers exist, where business logic lies and which dependencies were deliberately chosen.This document is at the same time context for people and for models.
  2. Think tests before the prompt: If the expected business logic is first formulated as a test case, the check shifts from feeling to commitment.Automated tests are the safety net that makes speed possible in the first place.
  3. Reviews with a clear question: Not only "does it work?" but "does it fit into this system, and would I find it again in six months?".Reviews are deliberately human work because they build system knowledge.
  4. Actively pass on knowledge: Pair work, joint walkthroughs and traceable commit histories replace what used to arise from working alongside others in the project.

Consequences for collaboration with service providers

For clients, this also shifts the question of what to look for when purchasing development services.A low daily rate or a short implementation time says little if it remains unclear how quality is assured.Sensible questions are: What test coverage exists for the critical paths?Who in the team can explain the architecture without looking at the code?How are AI-generated parts reviewed and documented?

These questions are uncomfortable, but they protect against the most expensive variant of a project: a system that works in the short term and in the long term belongs to no one.Especially with platforms such as TYPO3, which are extended over years and integrated into existing processes, maintainability decides the overall costs more strongly than the first implementation.

Assessment

AI tools do not change what makes good software – they change where the bottleneck lies.It is no longer the writing of code that is scarce, but the robust judgement of whether this code fits into a system.

For web and software projects, this means: tests, architecture documentation and genuine reviews are not add-ons, but the prerequisite for being able to use the gained speed at all.

Sources