Process · AI Workflow · 2024–2025

Multi-Agent AI Workflow

I built an AI-orchestrated prototyping pipeline — and what it taught me about product design.

Role

Solo builder / methodology designer

Project

Internal R&Dsandbox: ‘Don’t Tread on Cat’ game prototype

Timeline

2024–2025

Focus

AI orchestration
Prototyping methodology

01 · Context

Can AI replace specialised roles?

Product development traditionally needs specialised teams: architects design logic, engineers write code, QA validates. For solo builders, this creates a trade-off — build fast but brittle, or build properly but slowly.

I wanted to test a hypothesis: can AI agents replace these specialised roles if orchestrated correctly?

I picked game development as the sandbox. High complexity, fast feedback loops, empirical validation through runtime testing. The real goal wasn’t shipping a game — it was a workflow I could bring back to product design and prototyping.

The goal

Design an AI-orchestrated pipeline where each stage plays a specialised role. Prove it works by shipping something hard.

02 · The experiment

A pipeline of two AI tools and a runtime

Note: I use ‘multi-agent’ loosely throughout — a pipeline of distinct AI tools coordinated by a human, not autonomous agent-to-agent communication.

I designed a three-role pipeline: two AI agents and the game engine itself as the validator. Each had a distinct job and clear boundaries — no overlap, no ambiguity about who owns what.

AI Agent

Gemini 3 Pro

Architect

Role. System design, state machine logic, debugging strategy.

Output. Architecture docs, logic flow, refactoring plans.

AI Agent

Windsurf IDE

Executor

Role. Code generation, C# syntax, Unity API implementation.

Output. Functional scripts, component structure.

Runtime environment

Unity 6

Validator

Role. Where everything gets tested — physics, compile errors, real-time behaviour.

Output. Empirical truth — does it actually work?

Key insight

AI excels at structured logic but hallucinates on ‘feel.’ The validator stage is where the runtime tells you what the model can’t.

03 · In practice

What the loop actually looked like

In practice the three stages ran in fast cycles: Gemini described a state-machine change, Windsurf wrote the C#, Unity ran the build, I watched the result. If the build broke or the behaviour felt wrong, the validator output became the next prompt for the architect.

Side-by-side: code in Windsurf, runtime in Unity.

Unity editor showing the running state machine — Unity editor: state machine running.

Iteration cycle in the editor — Early prototype.

Runtime view of the prototype — Runtime view.

Unreal Blueprint architecture from the earlier attempt — Before convenient code-first with Windsurf, the early version sat on these heavy Unreal Blueprints.

Unreal compile times that killed iteration speed — Why Unreal didn’t work: 10-min compile times killed iteration loops.

Sharing progress with the dev community.

04 · Decisions

Three calls that made the workflow viable

Every decision was about preserving the empirical loop. The moment a validation step became slower than the agent reply, the whole approach lost its leverage.

Design decision

Unity over UnrealUnreal’s 10-minute compile times killed the AI iteration loop. The whole point of a multi-agent workflow is empirical validation in seconds, not minutes. Unity’s instant feedback made the methodology actually work.

Design decision

State machines first, graphics laterAI excels at structured logic but hallucinates on ‘feel.’ I validated mechanics before polish — proved the system worked before letting AI near anything visual.

Design decision

Human as quality controller, not coderAI can’t tell if controls ‘feel good.’ My job became orchestration, not implementation. Intuition is faster than parameter search.

05 · Results

What the orchestration actually bought

From days to an evening per mechanic

Mechanics that used to take 3–4 days collapsed to a single evening of work. The architect agent handled state machine design while the executor wrote the scripts, and Unity validated each iteration in seconds. The measurement is informal — my own development time before and after — but consistent across the project.

From hour-long debugging to ten-minute conversations

Where a stubborn bug used to mean a 3-hour session, the loop became a short conversation: Gemini diagnoses, Windsurf patches, Unity confirms. The validator stage replaced most of the guessing.

Solo velocity without role handoffs

Solo project velocity that previously needed coordination across roles. Not because AI replaced anyone — because orchestration removed the handoff cost.

06 · Lessons

What I learned

This workflow applies directly to product prototyping

Gemini = product strategist (defines system logic). Windsurf = engineer (implements). Browser runtime = user (validates). Same three-stage pipeline. Same separation of roles. Same speed gains when you orchestrate correctly.

The skill isn’t coding — it’s orchestration

Knowing when to let AI run vs when to intervene is the new craft. One concrete example: AI repeatedly suggested over-engineered solutions for the suspicion state machine — abstract base classes, interface hierarchies — when the right move was three plain if-statements. Stepping back at the wrong moment costs hours; stepping in at the right moment saves them.