Prompt-driven development, colloquially also called vibe coding, describes a way of working in which developers describe functionality predominantly in natural language and have the actual source code generated by an AI model. For a long time this was regarded as a playground for prototypes and small scripts. A current example shows that the approach now also supports larger undertakings.

Specifically, it concerns an open-source engine for the strategy classic Total Annihilation. According to reports, it was largely created with the help of AI and brings the game both to modern computers and to the browser. An engine is the technical foundation of a game: it handles rendering, input, game logic and resource management – precisely those layers that are classically considered particularly demanding.

Why this example in particular makes people sit up and take notice

A reimplementation project of this kind is not a weekend project. It requires dealing with existing data formats, with performance issues and with a target platform that differs significantly from the original in technical terms. The fact that such an undertaking can come about predominantly prompt-driven shifts expectations of AI tools: away from autocompleting individual lines, towards collaborating on interconnected systems.

At the same time, a sober look at the framework conditions is worthwhile. A project is always favourable for AI-supported development when

  • a clearly defined target behaviour exists against which the result can be measured,
  • errors become visible quickly because the result can be tried out immediately,
  • no regulatory or personal-data risks are involved,
  • and the undertaking breaks down into small, individually testable building blocks.

A game fulfils these points to a large extent. An accounting interface or a customer portal with data protection requirements does so far less. The transferability to one's own project should therefore not be assumed across the board.

What the AI takes on – and what it does not

Experience shows that AI-supported development shifts the focus of work rather than eliminating it. The time previously spent writing code migrates into three other activities.

First: architecture. The decision on how a system is divided, which modules exist and how they communicate with one another remains a design task. A model can provide suggestions, but the consequences of an architecture only become apparent months later – in maintainability, extensibility and operating costs.

Second: review. Generated code often looks plausible. Plausibility, however, is not proof of correctness. Especially with concurrency, memory management or edge cases in input processing, it takes someone who reads and understands the code instead of merely running it.

Third: quality assurance. Automated tests gain in importance when large amounts of code are produced quickly. They are the net that prevents a fix in one place from silently breaking another.

Speed is not the same as maturity

A common misunderstanding in decision-making rounds is: if the first runnable version is there faster, the project is finished correspondingly earlier. In practice, AI above all accelerates the path to a visible intermediate state. The subsequent phases – stabilisation, accessibility, security, performance under load, documentation – continue to follow their own logic.

Added to this is the question of responsibility. Anyone who uses code is liable for its behaviour, regardless of who or what wrote it. In open-source projects, the licensing question is added: the origin and further usability of components must remain traceable.

Practical consequences for teams

Some sober working rules can be derived from the example without having to overstate the approach:

  1. Use prompt-driven development where results can be checked quickly and objectively.
  2. Determine the architecture before the first prompt, not after.
  3. Treat test coverage as a prerequisite, not as a downstream task.
  4. Subject every generated change to the same review standards as hand-written code.
  5. Record which parts came about how – this makes later maintenance and licence checks easier.

The cultural aspect is also interesting: a project like this comes about in the open-source environment, where intermediate states are public and can be traced by third parties. This transparency is itself a quality mechanism – one that closed corporate projects must replace with internal processes.

Assessment

For web and software projects this means: AI-supported code generation is no longer a marginal tool, but a serious option for scopes that were previously planned in the classic way. The gain lies in the speed of implementation, not in the elimination of design, review and quality assurance – these tasks tend to become more important because more code is produced in less time. Anyone who wants to use the approach productively should therefore try it out in clearly delimited modules and adjust their own review processes to the higher pace beforehand.

Sources