Build a game engine with AI
How to build an AAA-class game engine with AI agents
We are building FRIENDLY?, a survival game on our own engine in Rust and Vulkan, built toward AAA-class graphics and netcode. The engine is written by AI agents under human direction and held to a strict contract: nothing merges until it passes its gates. This page shows the loop and the nine rules behind it.
What we are building
FRIENDLY? is a survival game in early development.
The engine is written in Rust (edition 2024) directly on Vulkan 1.3 or newer, with precompiled Slang shaders, the Bevy ECS crate, Jolt Physics 5.6 and DLSS and FSR upscaling.
Netcode is server-authoritative, on QUIC with TLS 1.3. The world is a real valley, about 6 by 6 km.
About 100 % of the code is written by AI agents under human direction. The game’s own project file puts the contract in one sentence: “Strictness is the product.”
The loop: plan, decide, lane, gates, merge
The same loop runs our game engine and goes into your repository when we set up your agents.
-
Plan
The owner owns the plan. Features go PRD → tasks → process.
-
Decide
Every decision is written down as an ADR before code exists.
-
Lane
One change, one lane. Specialist agents, one lead.
-
Gates
Tests and a lint wall that only gets stricter. A new gate must first fail once.
-
Merge
Only green work lands. Agents cannot loosen their own rules.
Nine rules that make agents reliable
Each rule has the reason behind it and one concrete example from the engine.
-
The owner owns the plan
- Rule
- People decide what gets built. Agents build it.
- Why
- Agents carry out a plan well. Choosing the plan is the part you cannot hand over.
- Example
- Features go PRD → tasks → process, and the plan stays with the owner.
-
Decide first, in writing
- Rule
- A decision is written down before code exists.
- Why
- A written decision can be checked and reversed. A decision hidden inside a diff cannot.
- Example
- Every decision is an ADR, and a new crate needs an ADR before it exists.
-
One change, one lane
- Rule
- Each change gets its own lane.
- Why
- A small, separate change is easy to review and easy to throw away.
- Example
- Every change in the engine lives in its own lane and must pass the gates before it merges.
-
Gates before merge, and a new gate fails first
- Rule
- Nothing merges until the gates pass, and every new gate is proven red before it is trusted.
- Why
- A check that has never failed may be checking nothing.
- Example
- The lint wall is the clippy groups all, pedantic and nursery plus about 70 restriction lints. Shipping code has no panics, unsafe code lives only in allowlisted crates, every item has docs, and tests come first.
-
The agent cannot loosen its own rules
- Rule
- The control plane is read-only to the agents.
- Why
- A rule an agent can edit is only a suggestion.
- Example
- Rules, hooks, agents and the lint wall are locked read-only.
#[allow]is banned; only#[expect(lint, reason)]is allowed, with a written reason. The wall only gets stricter.
-
Knowledge lives in files
- Rule
- What the agents need to know is written into the repository.
- Why
- What lives in a chat is gone in the next session. What lives in the repo is read every time.
- Example
- We keep project knowledge in repository files we call living skills.
-
A door agent and specialists
- Rule
- One lead agent receives the work and hands it to specialists.
- Why
- One agent keeps the whole picture. Specialists keep the depth.
- Example
- A lead “door” agent works with specialist agents for rendering, netcode and Rust review.
-
Hooks stop dangerous actions
- Rule
- Dangerous actions are blocked by hooks, not by instructions.
- Why
- An instruction is advice. A hook is enforcement.
- Example
- In the engine’s repository, hooks stop dangerous actions before they run.
-
No claim without a real run
- Rule
- A number is published only when a real run produced it.
- Why
- A number from memory is a rumour.
- Example
- We publish measured numbers only from real runs, with the hardware named. That is why this page has no frame-rate figures.
Three examples from the engine
Each example is a feature of the engine and the rule that stands behind it.
Weather fitted to real records
The weather model is calibrated on ERA5 reanalysis and on NCEI and DWD station records. It drives volumetric clouds and uses the real positions of the sun and the moon.
Rule 9 at work: the model is fitted to measured records, not to taste. The clouds are the part that is still unfinished; see below.

Trees where real trees stand
The map is a real valley near Ružomberok in Slovakia, about 6 by 6 km of real terrain. Trees stand where the valley’s 1 m LiDAR data says trees stand.
The choice to build on a real valley is recorded as an ADR, like every decision (rule 2).

Bullets without hitscan
Every round flies its own path under gravity, Mach-dependent drag and wind. There is no hitscan.
A feature like this is where “looks right” proves nothing, which is why the method asks for gates and real runs (rules 4 and 9).
What is not done yet
- Cloud shapes. The weather model drives volumetric clouds, but their shapes are not where we want them yet.
- Global illumination. In development, switched off by default.
- The game itself. It is early work in progress: a small playable scene with two houses, large forests and weather, and placeholder zombies that prove hit detection and networked ballistics.
- The AAA-class goal. It is the goal we are building toward. We do not claim parity with any other engine, and we publish no frame-rate numbers.
The setup behind it
Our own AI setup on Claude Code, in numbers: a system of 27 specialised agents with 73 knowledge modules and five in-house MCP servers.
Across our own products, nothing ships unless it passes PHPStan at its highest level and ESLint, Stylelint, TypeScript, Dart and Clippy at their strictest, plus 215 custom rules. Generated code gets no exemption.
Behind it stand more than 20 years of full-stack web development, more than four years of building with AI, and our own web framework in 18 languages.
Questions people ask
Can AI agents build a game engine?
In our case the code is written about 100 % by AI agents under human direction. The result is early work in progress, and a strict contract of rules and gates is what keeps it correct.
What makes AI-written code reliable?
Gates before merge: tests, a lint wall of clippy groups plus about 70 restriction lints, and further checks. On top of that, rules and hooks that the agents cannot loosen.
Is the game finished?
No. We are building it, and it is early work in progress. What is still missing is listed under “What is not done yet”.
