Spring Rider is a Powder-style top-down downhill mountain-bike game in Godot 4.5. You ride an endless spring forest, or race 15 rivals down a glacier-to-valley course traced from the real Mégavalanche. I wrote almost none of its code. A team of Multica agents and a Claude Code session in my terminal built it in 13 days, and my job was research, direction and saying yes or no.
This post is about how we worked: the research we did before the code, the free assets and sounds the game stands on, how I put the agent team together, and how the agents kept out of each other's way.
Six seconds of the endless ride, recorded in the game. The trail, boulders, tent and rock outcrops are procedural, placed by code the terminal session and the agents wrote.
Research came before the first line of code
The game started with a look, not a mechanic. I wanted the top-down view of the skiing game Powder, moved onto a mountain bike in a spring forest. The repo's first commit already had a docs/references/ folder: a Powder screenshot, a forest palette, a trail, a path, terrain relief, and two sheets of bike poses. Every agent opens those images at the start of every run, and every visual change gets judged against them. A day later the colours were all over the place, so I asked for an art bible and one palette file, and since then no agent invents a colour.
The first Multica agent's first job was research too. I asked it to read every Markdown file in the repo and do a deep dive before touching anything. Its first PR catalogued all 188 Kenney models with their sizes and material names and rendered a contact sheet, so later tasks could pick assets from a list instead of guessing.
The race followed the same pattern. On 27 September I asked Claude Code to look into the Mégavalanche at Alpe d'Huez, a mass-start race that runs from the Pic Blanc glacier to the valley. Two days later I asked the agents to read how riders crash in that race and put those scenarios in the game. That became a research issue with a rule that the findings must cite sources, and it gave the game its washouts on the glacier, its tangles in the pack and the walk back to the bike after a fall. When I wanted more riders in the race, I told the agents to check the real event to find a good number.
Midjourney drew the rider and the animals
The first version of Spring Rider was a 2D sprite game, and its art came from a Midjourney sprite sheet, rider included. The low-poly rider in teal, orange and white started there, and his pose sheets are still in the references folder. The game moved to 3D because sprites could not give us long shadows and lit trees. Claude Code then modelled the 3D rider and bike in Blender from a Python script (tools/build_rider.py), following those poses, so the animation code drives every limb without hand-made frames.
The wildlife went the same way. I made Midjourney renders of the birds, the deer, the fox and the bear and dropped them into the chat with a line each, such as "add a fox and a bear". Claude Code modelled and animated each animal in Blender to match the render. When the first fox came out wrong, I sent another render and wrote "redo the fox make it like this please". Midjourney gave me a fast way to say what I wanted, and the agents turned it into geometry that fits the low-poly style.
Kenney's free Nature Kit is the whole forest
Every tree, rock, cliff, stump, log pile, fern and bridge plank in the game comes from the Kenney Nature Kit. Kenney releases his asset packs under CC0, so anyone can use them in a commercial game with no attribution required. We credit him anyway, in the repo and here. Thank you, Kenney. A solo developer could not ship a forest this size without packs like yours.
The kit also solved the problem that sank the 2D version. The build log records the lesson as "cohesion beats fidelity": photo-real cutouts looked worse in the game than simple, consistent low-poly art. One style across hundreds of models fixed that. The game recolours each Kenney model at runtime from its material names, so the whole forest matches the palette in the references.
Every sound is a real recording
The first bike sounds were synthesised from noise by an agent. I had it check a paid sound library, and it reported that release rights there needed one of the top plans plus a credit line. I told Claude Code the synthesised sounds were bad, and it replaced them with real CC0 recordings from freesound.org: tyres on dirt and gravel, braking, snow creaking under a rolling snowball for the glacier, a spring forest afternoon, a stream, wind on a Pyrenees summit, and three bears for the roar, the chase growl and the snarl. A script in the repo downloads and cuts them, and a credits file names every recordist.
I removed more sound than I added. A freewheel click and a chain rattle went, the puddle splash became one short hiss because it was firing all the time, and music came in and went out again. "No music, just the sound effects" is the whole PR title. Those were taste calls an agent cannot make, and I made them by playing the game.
A GPS track of the real Mégavalanche shapes the race
I wanted the race to feel like the Mégavalanche, so the agents built its course from the real one. The World & Art agent searched for the real line and found Komoot's public tour "La Mégavalanche - Allemond depuis Pic Blanc": the line and altitude of the real course, 20.5 km from the glacier at 3,261 m down to Allemond at 770 m. It added slope data from SRTM 30 m terrain and resampled the whole thing every 25 m into a data file in the repo.
A Python script lays those 20.5 km onto the game's 3.1 km race and generates the course: how hard the hill pulls at each point, where the trail traverses across the mountainside, the plateau above Alpe d'Huez where you have to pedal, a short climb, and two forest switchbacks at the spots where the real course hairpins down to Oz. Edit the script's settings and run it again, and the course regenerates.
One detail from that issue shows why I want agents that ask. I had sent a Trailforks link as the source. The agent noticed the link was for the Mégavalanche on Réunion, not Alpe d'Huez, and asked before building. I kept our mountain and its zones and had it shape the race after the Alpe d'Huez course.
How to build an agent team, and how we built ours
We did not start with a team. We started with one agent and one rule, and grew from there.
Start with one generalist and a split by file. On the first evening I built one Multica agent in the agent builder by describing what I wanted: read the docs, deep dive, deliver work as pull requests, and protect the art direction we had chosen. Then I asked the builder how two agents could share one codebase, since Claude Code was already working in my terminal. The answer was to split by file. The terminal kept game3d.gd, terrain.gd and biker_rig.gd, and the agent (I named it "Get shit done") got everything else.
Write the rules into the agent, not into each task. The builder turned my seven chat messages into about 8,800 characters of instructions. They say what to read first, how to check for parallel work before editing, to prefix every branch with agent/, never to merge and never to push to a branch it did not create, and how to verify a change in Godot, and they carry the art direction in writing: one low warm sun, flat-shaded low-poly shapes, the palette, a trail painted into the ground with ragged edges. If a task would change the look, the agent stops and asks.
Split shared work with a contract. For race mode, the terminal session first opened a small PR with a contract: which files each side owns, and the exact functions each side calls on the other, such as start_race() and set_race(time_s, speed_kmh, zone_label). The terminal built the world and the race flow, the agent built the HUD, best times, sounds and tests, and the two halves joined with one integration PR.
Grow the team from the agent that already works. After five days I filed one issue: "Create a squad of agents to build this game. The agents in the squad can have all the knowledge and skills you have." The agent made four copies of itself, with the same instructions, model and runtime, and added a short role section to each:
- Lead sorts incoming work, splits it into ordered sub-issues and reviews the PRs. It never writes code itself unless a task is too small to hand out.
- Gameplay owns rider physics, controls, tricks, rivals and the HUD logic.
- World & Art owns terrain, the trail, props, Kenney assets, palette, lighting and shaders, and must render frames and compare them with the references.
- QA & Docs owns the test harnesses, performance, exports and docs, and checks other members' PRs without touching their branches.
- Get shit done stays as the generalist for small cross-cutting jobs.
The squad's own rule is to ask me before anything that would change the look or widen the scope. For Godot know-how, an agent added four open-source skills to the repo (optimisation, multithreading, debugging and export, from GodotPrompter, MIT), so every member gets them with the checkout.
Let the Lead write the briefs. I write requests like chat messages. One read, in full: "Do we need any improvements or changes, or can we deploy?" The Lead turns a line like that into sub-issues, each with a base commit, a branch, the files the agent may touch, the files it may not, and checks it must pass. When a request is vague, it writes down its reading ("Rivals.COUNT goes from 11 to 15") so I can correct it before any code exists. It also makes sure no two members edit the same function of game3d.gd at once.
Every agent ran Claude Opus 5.5. Claude Code estimates the whole agent team at about $222 at API list prices across the 13 days. The Lead, which only plans and reviews, was the cheapest member on the team.
The agents check their work by running the game
None of the agents opens the Godot editor. They run Godot from the command line and read what it prints:
GODOT=/Applications/Godot.app/Contents/MacOS/Godot
$GODOT --headless --path . --quit-after 40 # must print no SCRIPT ERROR
$GODOT --headless --path . --script res://tests/autopilot.gd
$GODOT --audio-driver Dummy --path . --script res://tests/terrshot.gd # windowed frames
An autopilot rides seeded worlds and reports how far it got and what it hit. Other test scripts check turning, hops, wall rides, rivals and frame time. Anything visual needs screenshots, which the agent opens and compares with the reference images. The build log's lesson: tests caught the physics regressions, and every visual bug turned up only when someone captured a frame and looked at it.
The QA & Docs agent earned its place early. It found that a falls PR from the Gameplay agent let riders wash out off the glacier, which the race rules did not allow. It measured what each extra rival costs per frame before we grew the field, and benchmarked the web build in Chrome, which decided which build the play page on this site ships.
I changed my mind on one feature four times
The canopy cutaway shows how the team handled a client who contradicts himself. The question was whether trees should turn see-through when the rider goes under them. I said no, then no again, then asked for it, and then asked for it gone. The Lead's brief for the build opened with "This reverses an earlier decision" and named the commit that had removed it the first time. On the last turn the Lead misread me and planned to extend the cutaway. I replied that the rider can be hidden behind anything bigger than him, and its next comment was "I had it the wrong way round". It re-scoped the work, World & Art removed the shader, and QA checked that nothing else had moved.
The briefs did not stop me contradicting myself. They did put the history in front of me every time, which is what I would want from a human lead.
What broke
- One machine for everyone. The agents and my terminal shared one Mac. During the web export the machine slowed to a crawl, and windowed tests played the game's sound while I worked. The fix was house rules: silent test runs, and short batches with the screen free.
- A quiet overnight run. One run on the course work went all night, pushed commits to a draft PR and posted nothing until I asked "What is the hold up".
No agent merged anything. I merged their PRs after looking at the screenshots and playing the build.
What I would do again
Collect references before code, and make every agent read them. Use free, consistent assets like Kenney's and real CC0 sounds instead of fighting for fidelity. Ground the hard parts in research with sources, down to a GPS track of the real course. Start with one agent and a split by file, and grow the team from the agent that already knows the project. Put a Lead in front of the team, because its briefs are what kept five agents and a terminal session from colliding.
If you have not set Multica up yet, I Gave My Coding Agents a Task Board covers installation and the first agents, and Three Coding Agents, One Repo covers what goes wrong without a team structure. The Multica listing has the licence and pricing.
Then go ride Spring Rider. It runs in the browser, wants a keyboard, and the race takes four to five minutes if you stay on the bike.
Thanks to Kenney for the Nature Kit, and to the freesound.org recordists credited in the game's repo.
