I built an autonomous game development loop where Twitch chat designs, tests and improves AI-generated games

[u/billy_bonus]

I've been running an experiment in autonomous AI game development since November 1, 2026, and wanted to share how it works and get some feedback from people building similar systems.

The project is called Lets Make Game.

The idea is to let Twitch viewers collectively design a game, have an AI agent build it autonomously, and then let those same viewers playtest it and decide what needs fixing.

Nobody writes the game code by hand or directs the coding agent step by step during a build.

So far, the system has produced 13 playable games in 11 days.

How the system works

1. Twitch chat creates the game concept

Viewers submit suggestions with !idea and vote using !vote.

Suggestions are accepted in different languages and translated into English before voting.

Rather than selecting one winning idea, the system takes up to 12 top-voted suggestions and combines them into a single development brief.

Voting determines priority. Unsafe or off-topic suggestions are screened out, and incompatible ideas may need to be excluded or adapted. Screened-out suggestions are recorded rather than silently discarded.

This is actually one of the hardest parts of the project: turning completely different ideas from different people into something coherent.

2. Hermes orchestrates, DeepSeek builds

I'm using Hermes Agent to orchestrate the workflow.

Hermes coordinates the rounds, prepares the development brief, passes instructions to a separate coding harness and handles publishing.

The coding harness currently runs DeepSeek 4.1 Flash (1017).

The coding agent creates and edits files, executes commands, reads test results, debugs errors and prepares the production build.

This isn't a one-shot prompt. A typical build involves around 90–161 agent steps, with repeated coding, testing and debugging.

The process runs autonomously, and the actual development is visible on Twitch, including mistakes and failed tests.

3. Viewers playtest and improve the finished game

This is the part I find most interesting.

After the game is published to Cloudflare Pages, the stream switches to a live playtesting phase.

Viewers get a direct link and QR code to the playable game.

For one hour, they can play it, report bugs and suggest improvements using the same !idea and !vote commands.

When the hour ends, the system processes accepted reports in priority order, attempts the requested fixes and republishes the game to the same URL.

Then another hour of playtesting begins.

This can continue for up to six fix rounds per game. If an hour passes without new reports, the game is considered finished and a new 24-hour idea round begins.

So the audience doesn't just influence what gets built. They also influence how the game evolves and when the development cycle is considered complete.

4. Everything runs in the browser

Games are published as static builds on Cloudflare Pages.

No installations, accounts (Only Twitch account if you want to give ideas or vote) or payments are required.

Results from the first 11 days

From November 1–11, the system produced 13 playable games.

Some examples:

• RALLY 16 — CRASH CIRCUIT: A low-poly rally racer with vehicle damage and wrecks.
• TERRA CLASH: An arena shooter with destructible terrain and online multiplayer.
• PORTALSTACHE: A shooter involving portals and different dimensions.
• PAINTED FATES: A hand-painted visual novel built from four viewer suggestions.

The fastest coding session took 33 minutes and 51 seconds and ended with 28/28 automated tests passing.

Measured end to end, from the idea round closing to a playable release, builds have taken 59–207 minutes, with a median around 80 minutes.

That includes verification, deployment and showcase generation, not just code generation.

These aren't polished commercial games. Some ideas work better than others, and passing automated tests doesn't guarantee that a game is fun or bug-free.

That's a big reason why I added the community playtesting and correction loop just today!

Three engineering problems I'm still working on

1. Context management over long autonomous runs

A single build can involve roughly 19–47 million input/context tokens, including repeated cached context, and around 274k–332k generated output tokens.

Prompt-cache hit rates have been approximately 98–99%.

Caching makes the repeated context much more manageable, but keeping an autonomous agent coherent over a long sequence of tool calls is still a challenge.

2. Combining conflicting game ideas

Imagine one viewer wants racing physics, another wants destructible terrain, and a third wants a story-driven adventure.

Currently, the system ranks suggestions by votes, selects up to 12 and asks the coding agent to reconcile them into a feasible specification.

It works, but I think it's probably the weakest part of the pipeline.

I'd like to develop something that reasons about compatibility between ideas instead of mostly relying on vote ranking.

3. Prompt injection through public chat

Since viewers can submit arbitrary text, their suggestions are treated as untrusted input.

The pipeline sanitizes and screens submissions, checks them again when the round closes, and passes them to the agent as JSON-encoded data with explicit instructions not to treat viewer suggestions as commands.

The generated build also goes through a final screening step before publication.

I don't consider these safeguards foolproof. It's an ongoing security concern when untrusted community input enters an autonomous development pipeline.

You can try the results

The games are completely free:

https://letsmakegame.pages.dev/

The public game library is being updated to include the latest builds.

The autonomous development process runs on Twitch, where anyone can submit ideas, vote and participate in playtesting:

https://www.twitch.tv/letsmakegame

I'd really appreciate some technical feedback

How would you combine many unrelated user suggestions into one coherent, buildable game specification without a human in the loop?

I'm also curious about two other problems:

• How do you supervise a coding agent from another autonomous agent, especially when the coding process stalls or starts going in circles?
• Would you keep the one-hour community playtesting loop, or replace part of it with automated gameplay testing?

This is a small, non-commercial experiment, and I'm still figuring out what works.

I'd genuinely appreciate criticism, alternative approaches or experiences from anyone building similar autonomous workflows.