DEV Community

Mathieu Ledru
Mathieu Ledru

Posted on

💫 I forced 4 AIs to recreate Mario from scratch using Symfony AI and Godot

Creating a video game with artificial intelligence has become almost commonplace.

Today, all you need to do is open Cursor, Claude Code or ChatGPT and type:

“Create me a Mario.”

And a few minutes later, something appears on the screen.

But behind this apparent simplicity lies a much more interesting problem:

How ​​to properly orchestrate multiple AI agents to produce a coherent, playable, and maintainable result?

That's precisely what I wanted to experiment with in this video:

  • ChatGPT
  • Claude
  • Gemini
  • Grok

Even prompt.
Same objective.
Completely different results.

But above all: a completely different architecture from what is called “vibe coding” today.

An inspiration from Playdate

Before even talking about AI, we need to talk about video games.

In the video, I quickly show the Playdate, a small independent console developed by Panic with a black and white screen and a mechanical crank.

What's interesting about the Playdate isn't the power.

That's the philosophy.

The equipment imposes constraints:

  • limited screen
  • minimalist controls
  • simple gameplay
  • maximum creativity

And paradoxically, these constraints make the games more interesting.

It's exactly the same phenomenon with AI agents.

A vague prompt often results in a fragile system.

Well-defined constraints produce much more consistent results.

The Single Prompt Problem

Most AI demonstrations work like this:

Create a Mario game
Enter fullscreen mode Exit fullscreen mode

The model then attempts to:

  • generate the gameplay
  • handle collisions
  • create the graphics
  • balance the levels
  • produce the mechanics
  • organize the project

The result is often impressive for a few seconds.

Then appear:

  • broken collisions
  • impossible levels
  • inconsistent rules
  • contradictory mechanisms
  • an immediate technical debt

The problem is not necessarily AI.

The problem is that he is being asked to do everything simultaneously without specialization.

Symfony AI + Godot

For this experiment, I used two main technologies:

Symfony AI

Symfony AI

Symfony AI provides:

  • the agents
  • the tools
  • multimodal
  • the RAG
  • memory
  • multi-agent orchestration

The framework is divided into several specialized bundles:

  • Agent
  • Store
  • AI Bundle
  • Platform
  • App

The goal is to build a clean architecture around AI models rather than simply sending prompts.

Godot

Godot Engine

Godot is an open-source game engine extremely well-suited for rapid prototyping:

  • 2D
  • 3D
  • scene system
  • GDScript scripting
  • nodal architecture
  • multi-platform export

The idea was simple:

Orchestrate AI agents with Symfony AI to automatically generate a Godot game.

Multi-agent orchestration

The core of the project is based on a multi-agent architecture.

Instead of having a single AI that does everything, I separated the responsibilities.

The Orchestrator

The orchestrator receives the main prompt:

Generate a Mario-like platformer
Enter fullscreen mode Exit fullscreen mode

Then it automatically delegates to the appropriate specialized agents.

Specialized agents

Layout Agent

The “level designer”.

It generates:

  • the platforms
  • the holes
  • the pipes
  • the stairs
  • the progression of the level

Gameplay Agent

The mechanics specialist.

He manages:

  • collisions
  • the enemies
  • the bonuses
  • the jumps
  • the checkpoints
  • the interactions

Godot Export Agent

The role of this agent is to transform the generated data into structures compatible with Godot:

  • scenes
  • TileMaps
  • objects
  • JSON exports

QA Agent

The most important thing.

The QA Agent verifies:

  • the gameplay
  • collisions
  • impossible jumps
  • the consistency of the mechanics
  • the rules of the level

This is probably the element most lacking in “vibe coding” demos.

The orchestration with Darkwood Flow and Navi

To orchestrate all of this, I use:

Flow allows you to manage the execution of multi-agent workflows.

Navi allows:

  • traceability
  • observability
  • routing
  • monitoring of executions

The pipeline looks like this:

User Prompt
    ↓
Orchestrator
    ↓
Layout Agent
Gameplay Agent
Godot Export Agent
QA Agent
    ↓
Generated Game
Enter fullscreen mode Exit fullscreen mode

The orchestrator automatically chooses which agent should intervene depending on the progress of the system.

A single Symfony command

The entire generation process is launched with a simple Symfony command:

php bin/console app:mario:orchestrate
Enter fullscreen mode Exit fullscreen mode

This order:

  1. calls the orchestrator
  2. Route to the specialist agents
  3. generates the result
  4. Automatically exports the game

The most interesting thing:
The pipeline becomes reproducible.

The results

ChatGPT

ChatGPT produces a very good database quickly.

We find:

  • a faithful structure
  • consistent gameplay
  • a rapid iteration

The result is strongly reminiscent of the old Mario Game Boy games.

The main advantage:
the speed of prototyping.

Claude

Claude produces something more graphically detailed.

The activities:

  • are more fluid
  • more modern
  • sometimes more ambitious

The reasoning seems more structured.

But we also feel more creative freedom compared to remaining faithful to the original.

Gemini

Gemini is probably the most visually interesting.

We find:

  • more modern graphics
  • better art direction
  • greater inventiveness

The gameplay also seems more refined in certain aspects.

There's a more "Nintendo-like" approach.

Grok

Grok is the most unpredictable.

He takes more initiative:

  • level selection
  • scoring system
  • graphic variations
  • new gameplay approaches

But it also deviates further from the original Mario.

The real subject is not Mario

This project was ultimately just a pretext.

The real issue lies elsewhere:

The future of AI development lies in orchestration.

A single agent can produce a prototype.

But several specialized agents can produce:

  • systems
  • pipelines
  • workflows
  • coherent architectures

And most importantly:
reproducible results.

The future of vibe coding

Current “vibe coding” often relies on:

  • a huge prompt
  • a single AI
  • many hallucinations
  • little validation

The next step is probably:

  • specialized agents
  • explicit constraints
  • tests
  • QA loops
  • observability
  • of the orchestration

In other words:

The future of vibe coding is orchestration.

Source code

Resources

Related Links

Links of the week

🎶 Music credit

@maya_cianflone

Questo trend è mio! ⭐️

♬ original sound - smb.0685

Top comments (0)