What Snake Games Have Taught Us About Shipping with AI Agents

Back in January, I wired up a Ralph loop to build Snake games and started dabbling in AFK development, with appropriate levels of human supervision, as needed.

Five months later, I am still coding the same game of Snake. Now 100% AFK, with much more confidence than when I started. Zero human supervision.

The first half of 2026 has been fun, but not in the arcade sense. It has been fun in the "I haven't touched my keyboard in twenty minutes, and every check on the branch is green" sense. We kept building the same Snake game. Same 20x20 grid. Same arrow keys. Same TDD spec. Same retro aesthetic.

The game has barely changed, but the delivery loop has changed everything.

If you have been watching the AI agent hype cycle from a safe distance, here is the compressed version of what we learned by staying stubbornly on one benchmark: you can go AFK with rising confidence, greener pull requests, and faster feedback than we have ever measured. Not by trusting the agent more. By giving it better and quicker back-pressure at each layer of validation.

The benchmark nobody asked for (but everybody needed)

Snake is a toy. That is the point.

A toy spec is small enough to run ten times in a week. Small enough to isolate one variable at a time. Small enough that when something breaks, you can actually read the diff instead of drowning in a monorepo.

We gave agents the same task repeatedly: build a playable Snake game from scratch using test-driven development (TDD). Seven tasks. Canvas rendering. Collision detection. Score tracking. Push commits. Open a PR. Walk away.

Every run finished locally. Every agent said the tests passed. Every game worked on the laptop and was pretty fun to play.

January: everything is a Ralph loop

In January, Geoffrey Huntley published everything is a ralph loop. The mindset shift is not "use AI to type faster." It is "program the loop."

Allocate a goal. Run the loop. Watch the failures. Fix the failure domain so it never happens again. Repeat until done or until you hit CTRL+C and take the wheel back.

Basic Ralph loops can build software and generate PRs AFK. That part worked decently well (with some light human supervision).

The PR at the end might be green. It might be red. The agent does not inherently know which until something external tells it.

We were building Snake games in loops before we had a name for what we were doing.

The lesson from January: autonomy without validation is just faster guessing.

February: does the pipeline agree with local tests?

By February we had data, not vibes, on whether the pipeline agreed.

Our first study ran ten controlled Snake builds. Same spec. Same model scaffolding. One variable: five runs wired to CircleCI through RalphCI, five runs without.

All ten agents completed every task. All ten passed local tests. All ten declared victory.

Eighty percent of the no-CI runs shipped code the pipeline rejected. The failure was mundane: single quotes where ESLint wanted double quotes. Local tests do not check lint rules. CI does. The gap between "works on my machine" and "works in your pipeline" is where agents lie with confidence.

RalphCI fixed that by injecting real pipeline status into the agent loop after push. When CI failed, a CI Doctor agent read the logs, applied fixes, and pushed again. Twelve failures across five runs. Twelve autonomous fixes. Zero human triage.

The breakthrough in February: agentic loops with CI back-pressure can land green PRs AFK. The final PR passes CI. Commits inside that PR might still fail along the way. Red commits on the branch. Green at the end. Progress, not perfection.

Early May: every commit has to be green

Three months later we hit the next failure domain.

Local pnpm test:run kept passing on my Mac. Chunk sidecars kept failing on Linux. Missing LEGAL_DISCLAIMER.md. Missing SNAKE.md experiment marker. A TypeScript compile error the Snake workspace's local tests never exercised but a full pnpm build caught.

Same pattern, five runs in a row. Local green. Sidecar red. CI Doctor lands a fix(ci-sidecar): commit. Sidecar green. Push allowed.

Our early May study wired Chunk sidecars into RalphCI's Review Gate. A sidecar is a lightweight remote microVM: your workspace syncs there, Chunk runs a microbuild that mirrors your pipeline intent, and you get CI-shaped feedback before the branch leaves your laptop.

Five Snake builds. Five 100% green PRs. Every commit green. Not just the last one.

I had not touched the keyboard in twenty minutes. The final PR (and every commit on it) was green anyway.

This screenshot is what HIGH CONFIDENCE looks like.

The May breakthrough: three validation layers (local, sidecar, pipeline) produce PRs where humans review green branches only. Sidecars catch CI-shaped failures while the agent still has context. CircleCI remains the authority at merge time. Sidecars extend CI into the inner loop. They do not replace it.

Late May: deliver the same green outcome, faster

100% Green PRs answered "can we merge with confidence?" A follow-up experiment asked "how fast can we merge with confidence?"

Our late May study ran the same ten Go tasks two ways on chunk-cli: sidecar validation per iteration versus commit-push-poll CircleCI per iteration. Same agent. Same model. Same gate jobs (lint and test). Different machinery.

Sixty-nine seconds. Every iteration. Five replicates in a row. That is not random noise in our harness. That is the queue tax on push-per-task CI.

Twenty-two seconds on a warmed sidecar snapshot. Same question: are lint and test happy right now? Same answer. Different delivery speed.

Token spend was flat because in this particular experiment tokens tracked fixes, not wait. The CI arm burned more clock time, not more intelligence, so sidecars did not shrink the LLM bill here. They shrunk idle time. On a ten-task run that is roughly eight minutes of gate-waiting saved before the final pipeline epilogue.

The May speed breakthrough: you still want an outer loop. Sidecar runs finished with a full ci workflow epilogue after one push. Fast inner loop on each task, authoritative pipeline confirmation at the end. Not sidecar-only cowboy coding. Not push-and-pray either.

Four layers, one arc

Strip away the Snake skin and the arc looks like this:

We are not gaining more AFK confidence because we trust agents more (although the models have improved since January). We are gaining more AFK confidence because each failure domain we hit got engineered out of the loop. And we've even unleashed some speed gains along the way.

Watch the loop. That is Huntley's line and it is the whole game.

• January taught us to program the AFK agent loop.
• February taught us the agent's "I passed" is local theater without CI.
• Early May taught us that 100% green PRs are possible, given sidecar validation before commit and push.
• Late May taught us that 100% green PRs are still the prize, and sidecars get us there faster than push-per-task CI.

Snake games did not teach us that AI writes good code. They taught us where validation has to live when the coder is an agent loop and the reviewer is still a human with a merge button.

What I am actually doing with this

I am obviously not shipping Snake to production. (Unless you've been craving retro gaming experiences. DM me.)

I am shipping the stack: RalphCI orchestration, Review Gate with local checks plus Chunk sidecar validation, CI Doctor for autonomous repair, CircleCI as the outer loop authority. Same pattern we pressure-tested on a toy game because toys fail fast and teach faster.

Four layers, one arc. Program the loop. Wire in CI back-pressure. Validate on sidecars before push. Maintain CI pipeline authority at the end.

Each layer kills a failure domain the last one missed. Confidence climbs. PRs go greener. Feedback gets faster. The human at the merge button only reviews green.

That is what five months of the same Snake game bought us.

Green CI is still priceless. Everything else is noise.

Where to read the lab reports

• everything is a ralph loop (Geoffrey Huntley, Jan 2026)
• We Let an AI Agent Say "I Passed." Was It Actually Good? (Feb 2026)
• AFK Builds with 100% Green PRs (May 2026)
• The Sidecar Race: 22 Seconds vs 69 Seconds (May 2026)

More Snake runs coming. Heavier repos. Flakier tests. Parallel agents. Improved CLI. Better agent-facing APIs. You name it.

The benchmark stays small on purpose, and we intend to scale the lessons as we go.