A browser game built in 10 days for Meta’s Global AI Developer hackathon from zero game design background

Two ways to read this

  • The project: how I built a physics ninja game in 10 days, and what broke. Start with the next section, “What is ConquerCourse”.
  • The hackathon: how it was run, what the judges said, the winners, and what I noticed. Skip straight to Hackathon Experience near the end.

What is ConquerCourse

ConquerCourse is a browser game where you run, jump, vault and swing through a ninja-warrior course, and every obstacle teaches the physics behind it.
You can learn the ideas in the Dojo and in the Labs, which go on into search, timing and other computer science.
You can also build your own course from real parks and photos, share it, and race a ghost of the best run.

Watch the Demo: https://www.youtube.com/watch?v=Nu1lxGTUyLE
Play it in your browser: https://conquercourse.pages.dev/
Hackathon Gallery: https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/4115
Tour my 10-day Development Timeline: https://conquercourse.pages.dev/making-of/timeline

Agenda

This article describes the end-to-end design and build process, what broke, and what I would do differently.

In this post:

  1. How the idea came to be
  2. Project management tools and processes
  3. Game design and development details
  4. User Generated Content and Abuse prevention considerations
  5. Demo creation
  6. Challenges and Surprises in Development
  7. Organization, Discord community, Judging Feedback
  8. Skills gained, and how I would do it again
  9. Appendix of Claude devlogs

Humble Beginnings

Felix’s article on 4 kinds of ambition

I did it with AI coding agents, a pile of mistakes, and a push from Felix Rieseberg’s essay on ambition with AI, which argues we are held back by what we believe is possible.

Felix names four types of ambition. Here is how I pushed each one:

  • Speed: 1,345 commits, 4,978 Tracked files, Game source (src/): ~49,600 lines
  • Altitude: Reasonably accurate moves on obstacles
  • Depth: one 120 Hz simulator behind the game, labs and server checks
  • Range: photo-to-3D, rigging and animation, solution search and optimization, user-generated content

The Idea Pivot

My first idea was to bring da Vinci’s machines to life to teach physics.
I got stuck fast: the Codex Atlanticus has few photos good enough to rebuild in 3D.
I asked a smaller question: what is the simplest thing that still teaches how forces work?
I grew up watching Takeshi’s Castle (it aired locally in 1998), and an obstacle course is physics you can feel: a wall, a rope, a gap.
The ninja warrior course was the natural answer.
Lesson: when the big idea is blocked, shrink it until it works.

Getting more ideas

I went through parkour books to understand the vocabulary, so I can search for sample videos to create realistic moves for my characters.
Coming from zero game development background, I also went through 10 game design books to learn design principles and inspire brainstorming.

The idea was the easy part. Building this much in 10 days meant working differently from my last hackathon, so here is how I worked.

Parkour Books

How I worked — Processes and Tools

Last time I won Google’s AllThingsAgentic hackathon on free models, working around daily resets on Cline. It worked because I did the thinking. I read the code and docs, designed carefully, and spent about three hours writing a single prompt.

Claude

This time, I decided to go for Claude Max ($100 monthly) to see how far I can push it. I completed the whole project on Sonnet 5.5 instead of Opus to save tokens, and it worked great. I barely reached weekly limits once, which tells me the plan upgrade was the right choice.

Linear

I also started using Linear to track my agents’ progress.
Linear MCP is used for Claude to write Linear issues, and Linear webhook is added to Github integrations so a merged PR closes Linear issues.

Claude wrote the Linear issues, and I asked it to open each with a “so what” before the technical details. The free plan caps active issues at 250, so I archived old ones and updated existing issues instead of creating new ones. That cost me the kanban view, but I did not mind: as the agents got faster, even the issues were too wordy for me to follow, and I had to move up the abstraction ladder.

Abstraction Ladder

Playtest: If it does not feel right, don’t waste time fixing invisible bugs
Issue Map: where I check that each area is sufficiently developed
Linear: the “so what” of each change, if code is not important
Docs: when I want to get a comprehensive view of what’s already decided
Code: only when something needed my confirmation

My rule:
Start high (playtest) to low (code).
Importance depends on visibility to players, reversibility, and abuse potential.
Higher importance warrants looking into lower abstractions.

Issue Map

ConquerCourse Course Map

I understood early on I cannot catch up to the development speed, so stopped reading some issues and created this map so I can focus on getting the core mechanics right.
I read the START, BASE, CORE columns, and Foundation row in depth, while skimming the others to ensure they are what I intend.

Linear Issue Map

Agents

Claude Code on my laptop was the main controller. Everything else was extra hands, each with one job.

Where the work ran

  • Laptop: Claude Code as the main controller, and all playtesting, because quick feedback loops matter most there.
  • Long-lived VMs (Vultr, from $300 of new-user credits): long CPU jobs such as feature development and testing.
  • GitHub Codespaces (120 free core hours a month): big force pushes that correct mistakes in history, because they sit close to GitHub’s servers on the network.
  • Serverless GPUs (Modal, $30 a month plus $100 one-off for the hackathon): computer vision experiments that need a GPU, such as SAM 3D.

Which models I used

  • Claude (my own subscription): the main coding agent.
  • Codex (Student plan): a second opinion and extra capacity to explore design questions, update docs and solve performance optimizations and searches by my simulator causing UI blocking
  • Meta Model API ($150 of credits): the hackathon’s required models.
  • Baseten (about $100, but I never saw the real balance): the hackathon gave everyone a shared workspace key and switched it off afterwards, so I could not check how much was left.

How the work was split

Each feature lived in its own git worktree on a VM, named after the job (for example conquercourse-film and conquercourse-graph). When a folder was finished, I copied its changes to the laptop. The main agent reviewed them and pushed from one single source, instead of every VM testing and pushing for itself.

The cost is more tokens. The benefit is coherent changes without merge conflicts.

Where Meta’s models fell short

Meta’s models ran extremely slowly, for reasons I never found. One of them spent at least a whole night making a very low-quality demo film, and after that I gave up on them completely.

I set them up by pointing Claude Code’s Anthropic environment variables at Meta, following the official setup guide. That setup loses Claude’s auto mode, so I had to approve every tiny change in each new worktree. Automated coding became extremely high friction.

Technical Details

The spine of ConquerCourse is one simulator that runs at a fixed 120 steps per second and always gives the same result for the same keys. The game, the Dojo and Labs, and the server checks all use it, so they never disagree.

The diagrams below show how the pieces connect.
The simulator is explained after the tech stack.

Overall Architecture

Overall Architecture Diagram

Meta Tooling and Data Processing Specific Architecture

architecture diagram of meta models vs custom scripts

Tech Stack

I tried Unity for 4 hours and gave up. It was the right decision in retrospect.

  1. It looked no better than three.js in the browser. A blind test showed the engine doesn’t change the look, the art and lighting do.
  2. Every change slower to see (5 min rebuild per code change, 50 secs with optimizations), and every page heavier to load.

I don’t want every small change to cost seconds of compilation.
For debugging I want WYSIWYG style.
If I let coding assistants work with Unity, I probably won’t understand how the code they’re changing relate to how it really looks.

Browser technologies were chosen to keep the game accessible and easy to playtest.
Other participants provided .exe files which people would be more wary of.

When Unity would make sense: a later product for consoles or VR, or heavy real-time effects like cloth or crowds that a video can’t fake

Experience Design

Diagram related 4 in-app experiences

It started as a messy sprawl of features, but after grouping into screens and setting up sensible navigation paths, the whole problem became intuitive.

Obstacles

Obstacles began as classics like Warped wall, trampoline, rope to make it easy for players to know the interactions expected. They also made it easy to generate associated physics lessons in the Dojo.

Movement

Motion capture clips, and Youtube CC licensed clips were used to create realistic movements (climbing over wall, vault).

For motion where real clips are hard to find, Kimodo text-to-motion model helped in generating realistic motions (slide) where motion capture videos were not available.

Visual Debugging

Playtest of pop vault motion

It was interesting to see how I can define contact targets in text and Claude could fix the Inverse Kinematics to make the motion right.
For example, I prompted a wall climb to have hands on top of the wall’s ledge, and a kick into the wall to push the character as much as needed to reach the top of the wall.
The motion above in gif is exactly from https://youtu.be/gP9CHhAmEP4?t=35
Claude was also good enough to create roll motion even when the real rolls in videos are coming towards the camera, by turning them into a side view.
Having url flags made it convenient to playtest new features.

I ran a blind test of Kimodo’s text-to-motion clips against real motion capture. I chose Kimodo’s movements first because they looked graceful, but after down scoping to remove moon gravity, I chose motion capture. Details are in the Appendix.

Keyboard Input design

The moves are directly related to keys.
I aim to follow typical conventions like WASD for directions, with multiple inputs to the same command for left handers and right handers (WASD vs arrow keys).
S can stand for down or Slide depending on the state of the character.
If the character is in the air and landing soon, S bends knees to break fall.
If he is on ground and running, S slides under cannonballs.

Monkey bars use Q and E so the left hand does not have to reach to the right side of the keyboard.

Rope initially auto attached to the character, but I decided to make it more realistic by requiring to hold E to grab the rope.
This is like how in the real world, just holding on requires constant effort.

My hypothesis is that practising on a keyboard builds coordination that carries over to the real task. The keys trigger the same brain pathways as the real movement, just on a smaller scale. Three things made me believe it:

  • Piano to drums. My piano skills transferred to the drums. Hands-only drumming was easy, because coordinating 10 fingers is harder than coordinating 2 wrists or arms. The only new thing was the 2 legs.
  • Drum app to drum kit. I practised on the Real Drum App, and it helped me play my electronic drum kit better.
  • Sports visualization. Athletes report better performance from imagining the movement, without touching any equipment.

I tried to recreate the Body Prop obstacle by requiring 3 of 4 keys to always be held down, but gave up after realizing not every keyboard has advanced Key Rollover capabilities (recognizing multiple simultaneously pressed keys).

Characters

Tripo’s developer outreach on Youtube is strong, so I decided to try making my main characters using it.
I signed up for 2 Tripo developer programs but they didn’t get back in time before hackathon ended. Maybe I will find more use cases if user growth takes off and I still want to work on this project.

1. https://developers.tripo3d.com/en/collaboration-program
2. https://studio.tripo3d.ai/creator-hub/mission-tripossible/

It was expensive, 5 USD for 500 credits, and 1 generation already used 110 credits.
I had to repeat a few tries while figuring out the look at generation format (quad vs tri-mesh, number of polygons etc).

Attempt 1

character generation attempt 1

Cute but the proportions won’t show the beauty of movement.
Lesson: describe body proportions (7 heads tall), not only the style.

Attempt 2

character generation attempt 2

The face needs its own prompt, but I had a creative workaround.

Attempt 3

character generation attempt 3

Prompt:
Stylised athletic teenage ninja for a kids’ science game, matte toon style, simple flat colors, no fine texture detail. Natural human proportions, about 7 heads tall like a 1.7 m teenager: slim athletic build, long arms and legs, visible neck, defined shoulders, elbows, knees and ankles. Fitted navy gi with tight sleeves and trousers, solid red belt with a short knot, solid red headband with no tails, black mask over the lower face showing only friendly eyes, dark flat-soled tabi shoes. Each part one solid color. Mitten hands with a separate thumb. Symmetrical T-pose facing forward, arms straight out at shoulder level, palms down, legs straight, feet shoulder-width apart, gaps under the arms and between the legs. No weapons, cape, scarf, loose cloth, wide sleeves, baggy trousers or accessories.

This still felt too serious. I also didn’t want to get pigeonholed into a ninja brand, so I put all my hope into the remaining credits worth last 2 tries.

main characters bad rigging

Attempt 4

main characters good rigging

The guy looked ok, so I used muse image to create a prompt for a girl too.
I got exposed to rigging after seeing the guy’s arms break off.
After a few tweaks to connect his arms and fix bad posture, both characters look like they fit their skeletons well.

extra characters

Making do without Tripo Credits

Without any more Tripo credits, I used Muse Image to create 2D characters, then SAM 3D Objects to lift it to a mesh, and a python rigger to apply the same 34 bones to each.
The point was to prove that they look reasonably convincing and can perform all the moves in the game.
Skater, Banana, and Potato are facing the wrong way, which led to interesting weighted heuristics to find where’s the front (e.g. shoe point vs knee position).
Jellyfish had no shoe and looks flat, so it was harder to get right.
Whatever the character looks like, every one of them is judged by the same referee: the simulator.

Simulator on a single 120Hz Clock — The linchpin

The most important choice was a single simulator that runs at a fixed 120 steps per second and always gives the same result for the same keys.

Because of that, one engine can be the referee for everything:
1. Decide whether a course edited by a player can be cleared, and find shortcuts.
2. Check a submitted run on the server by replaying it.
3. Find the ideal run, so a ghost can race you.
4. Power the lessons in the Dojo and Labs.
5. Draw the predicted jump path in Debug mode.
6. Calculate how early or late a key press can be, and tune the difficulty from that.

simulator runs

Dojo and Labs

I first built the Dojo only to teach physics, for ages 7–18.
Then I thought it was a waste to leave out all the computer science teaching potential. A game that already simulates jumps, search and timing can teach those ideas too.

labs

Try one: the Search Lab

The game must check that a course can be cleared. That means searching for a line through the obstacles.
The Lab shows the problem on a trap course. The farthest first jump strands the second.
Greedy Search takes the farthest jump each time and gets stuck.
A* Search looks ahead and clears it.
The Lab shows the run counts side by side. The game’s own search runs next to yours, with its real count.

See it in the game

The World Editor runs a search on every course to check it can be cleared.
If no run is found, Improve -> Ask AI for ideas button suggests edits, and the simulator previews each one before you apply it.
If the course clears but one press is very tight, Improve -> Make it easier button tries small changes to widen that press window.
Make it easier only works on a course the search has already cleared.

Network Effects

Leaderboards were added to make the game more interesting.
There are design tradeoffs in when to refresh them.
If done too infrequently, new comers feel hopeless in beating the records.
If done too frequently, existing players feel like their effort is wasted.

Creating a shareable link to a recorded run is an involved task that relates to how to hash and verify runs to prevent cheats, with our simulator at the center.
This link to challenge a previously played ghost makes it easy to get started on the game with a 30-second experience, without even needing to navigate through course selection screens.
https://conquercourse.pages.dev/?course=/assets/demo/training.course.json

Leaderboard in end of run screen

User Generated Content and Abuse Protection

A leaderboard and a share link are easy to build.
Sharing means strangers’ content, and that is a different problem.

With 2 days left, I realized what a Pandora’s box supporting UGC is.
I scoped down from creating an entire course from a drone photo to creating individual obstacles from ground-level photos.
UGC brings volume and abuse if left unchecked, and it affects database design and UX.

I set up six layers of defense:

  1. Cloudflare Turnstile guards the two paid routes, make a piece from a photo and Make a character, so bots can’t burn the AI budget.
  2. AI review first. Muse Spark checks every uploaded photo before the outline step, the 3D lift, a character picture or Share in Community. The words for a character go through the same safety check. Anything it doesn’t pass stays hidden and goes to an admin page that only I can open, where I review it. Community photo pieces also need approval. Street photos use Mapillary’s face and plate blur, and I also reject close-ups and large people.
  3. Private until Publish. A made character is seen only by its maker until they publish it.
  4. Simulator proof. An edited course is shared only after the simulator proves it can be cleared. A challenge course then appears in the Community list only after another player clears it.
  5. Server replay. A ranked run counts only if the player published it and the server replays its keys to the same result.
  6. Daily limits on shared and paid actions (details below).

Database: different things need different storage

  • Stays in your browser: your chosen character, your editor world, and the undo list for your current visit. They cost us nothing and only you see them.
  • Goes to the server: only shared things. That means characters, challenge courses, ranked runs, community pieces and share links.
  • A character is private or published. Private means only the maker sees it. Published means everyone sees it.
  • Cleaning up, so the shared pool can’t grow forever:
    A private character is removed after 30 days without use.
    A published character with fewer than 10 picks is removed after 14 days without being picked.
    A character with 10 picks becomes a “Keeper” and stays.
  • Size caps: a shared photo is limited to about 340 KB, and a shared 3D piece to about 1 MB.

UX: telling people what happens

  • Limits exist because making a character or a photo piece runs paid AI steps, and every shared thing fills a shared panel. A limit protects the budget and keeps one player from flooding it.
  • Limits sit only on shared or paid actions. The editor, your own world and your chosen character cost nothing, so they have none.
  • A repeated prompt reuses the first result, so the player gets an answer without a refusal.
  • The counter says “N of M left today”, so the limit reads as a rule and not an error. A private character also says how long it is kept.
  • At the limit you can still play, edit and browse.
  • Retention: the daily reset gives a player a reason to come back tomorrow. With only a few makes a day, players choose carefully, so published things are better and the panel is worth visiting.

One skeleton, so courses still work

  • We can’t design courses around characters we’ve never seen, so every character is fitted to the same skeleton.
  • A short-armed Banana can’t make a course impossible, because reach comes from fixed numbers in the simulator and not from the mesh.
  • What can break is the look. Seven of the eight test characters had arms 22 to 51 percent too short, and the fit stretches them. The Banana still rated “extreme” on the fit report.
Real world pieces in World Editor

Meta Tool Use

Hackathons partly exist to test the organizer’s tools, so I used as many as fit

Meta Tool Use in App

Demo — Art and Music Direction

I discovered that I can describe scenes to the agent, and let it play through my game and take screenshots and videos along the way, so this was my first storyboarding experience.

storyboard

Scenes

Each 15 second scene could take 15 minutes to record.
It was extremely tedious but realistic. For shots where AI is lacking, I do the recordings myself.
However AI has to do the job when scripting the camera movements, because I cannot play the game with 2 hands while moving my mouse in a smooth curve the exact way I want it.

Sample script for last 3 scenes

Here is a real storyboard prompt. I give the agent a start screen, what to click and how long to hold each view, and it plays the game and records the shots. More scene prompts are in the Appendix.

Scene 6: Learn the Basics
Start from the Dojo Gap Jump screen 2 seconds on The real obstacle default tab , click The idea (2 seconds on this)
Click “The exact formula” and drag the sliders to show graph changing (2 seconds).
Click rope swing tab (2 secs), stored energy tab (2 secs)

Programmatic filming

The benefit of programmatic filming is that we can manipulate the cameras and UI in a way that would be tedious or impossible otherwise.
We can hide UI panels with a style tag when filming the scene only.

Lag vs smooth: https://lnkd.in/p/gjPdXBcY
Filming initially created laggy videos due to a slow renderer and the clock stepping in real time.
After changing the filming clock, it waited for every frame to complete rendering to create smooth videos.
In a 20-frame test, Mesa’s llvmpipe renderer ran 5 to 10 times faster than SwiftShader (about 17 frames per second against 2 to 3).

Music

Creating music exactly the way I want requires using the right vocabulary, designing for the user’s mental state, and user journey through various parts of the app.
Initial D anime made car chase scenes feel fast with Eurobeat.
For my app, I needed both fast in obstacle course running, and relaxing in Dojo and Labs.
Users spend a lot of time in labs so the music has to sound good in a loop if the clips are short. It should not contain ear-catching motifs that would sound bad if cut midway.

Music for demo is also different from music in game, where the demo music should be more exciting, and fit the demo scenes and transitions, which may not occur in the real game.

Slicing buildings in World Slicer

Challenges

UGC was the hardest part of the project, and music direction was the second hardest and the most fun.
The simulator, search and physics were technically harder, but I let agents carry those while I stayed at the top of my abstraction ladder and worked on design.

That left me with design problems. Seven came up: five took real thinking, and two were smaller.

1. Multiple paths in one course

The problem: Players should be able to choose between a safer low path and a riskier high path, such as the high monkey bars. More freedom means more unwieldy data structures, so the way a course is stored must be designed carefully.

Three things to balance:

  • Payoff: the high path must be worth the risk of the harder route.
  • Leaderboard: if the low path is always better, nobody chasing the leaderboard will try the high path. Separate leaderboards for each path are one option.
  • Which path was taken: players can drop down from the monkey bars at any step, so heuristics are needed to decide when the high path counts as taken.

2. Should space represent time?

The problem: How do you tell the player when to press a key? I compared two arcade styles: Taiko drums, where time-sensitive hits scroll toward you, and Street Fighter combo trials, which are not time-sensitive in the same way.

  • Why not for Street Fighter: it is fast, so the timing intervals vary a lot. Combos are also long strings of complicated inputs, including the joystick. Using space to show their timing would waste screen space.
  • Why it works for my game: it is slower and basically a side-scroller. Scrolling drum beats, spaced by timing, get past the screen-space problem and still guide the player well.
  • The catch: the timing is inexact. The simulator cannot know ahead of time whether a player will run off a ledge or jump off it, so the real moment to press X to roll shifts. So the timing windows have to be wide enough for presses to be recognized.

3. Space and timing of key presses

Reach. While designing the lache pair obstacle, I had to decide how far the body can fly and still grab a bar. A bigger allowance makes the game easier, but it also makes the simulator’s job harder, because there are more solutions to search. Realism matters too: the gap should not be so large that even a fully stretched arm obviously cannot reach the bar.

Spacing. Spacing affects obstacle design as well. If a player can grab a bar from very far away, the simulator may get confused when bars sit close together, as they do in monkey bars.

Timing tolerance. Timing must be forgiving enough for the player. The drum lane should help players pass courses, but most first-time players go by the visuals. If the character is only halfway up the warped wall, expecting the player to press E early to grab the ledge is unrealistic. So the visuals themselves must prompt the right key at the right time.

Key holds. Holding a key makes timing easier for the player, who only has to press early enough and hold, instead of tapping at the exact moment.

4. In World Slicer, keep the part above the slice or below it?

  • Keep the part below: the skyline becomes a boring flat top.
  • Keep the part above: the uneven skyline can make most of the course unsolvable, because the simulator sets a physical limit on how high the character can jump. The whole course would have to shrink to tiny proportions to be clearable.

What I chose: a later idea was to start the character on one of the roofs, instead of at the slice height, which acts as the floor. Height differences between rooftops are smaller than the difference between the sliced ground level and the tallest building in the lane, so the simulator found many more solutions. This eased a UX problem: players spending too long in World Slicer and World Editor without finding a clearable path.

5. Privacy of people in photos

The problem: I wanted to add street-view photos to World Slicer. In the Shibuya screenshot above, the Mapillary photos line up along a single lane, and looking through them feels like travelling along that road.

The catch: if we masked out all people, almost no photo would pass.

What I chose: accept a photo if the people in it are far away and small, and let Mapillary handle the blurring and privacy reports. For photos that users upload to create obstacles, I do my own blurring.

Two smaller ones

Fun or realism. This choice affects how movements look, which obstacles exist and how the physics works. If everything stayed realistic, there would be no room for moon gravity. I eventually removed moon gravity to scope down. Extra obstacles like the pole vault, cannon and rollercoaster add a lot of fun, though.

Too many features and buttons. At one point every screen had so many buttons that I lost track of what was going on. I did two major refactors and several UI cleanups. Every button now has an intuitive reason to stay, and I clicked every single one to check why and when someone would want it, and that it leads to the most intuitive next step.

World Editor screen in ConquerCourse

Pleasant Surprises

These were things I did not design for that turned out to be surprisingly impactful.

1. The rollercoaster made the game feel real

Adding the rollercoaster was the first time I felt this game was really cool. Designing coasters with draggable splines was Claude’s idea, which it came up with unprompted.

2. The first-person camera is playable

I was surprised to make it through the lache pair completely in first-person view. I believe there is real potential in training kinaesthetic intelligence through this game.

3. The Taiko drum lane calmed first-time players

The lane shows key-press instructions, inspired by the arcade game. It reduced the stress of first-time players and is an effective onboarding tool for any new course.

4. The debug view helped without spoiling the game

It started simply as a speed meter, to show whether someone had picked up enough speed to get up the warped wall. It turned out to be surprisingly helpful to also show where a jump will land at a given speed. It helps, but not so much that it spoils the game.

5. Muse Spark could place obstacles in 3D space

In World Editor, Muse Spark could suggest new 3D locations for my obstacles to make a course clearable.

6. The code map showed me where to focus

My graphify map (10,760 nodes and 30,409 edges) was clear enough to show me where to focus, and whether I was still on top of the vibe. It is a customized HTML page built on top of the default map, because once a map exceeds 5,000 nodes the default cannot drill down.

7. Singapore has a parkour park

While filling my World Slicer screen with parks around the world, I discovered Singapore’s parkour park at Lakeside Garden Skatepark. Singapore takes vandalism seriously and protects its public structures well, so it surprised me that the government supports people jumping around.

How would I do it again

Fitting the hackathon themes

Build for Your World. Bring Meta’s models into your domain. Solve a problem you know firsthand, free up time and mental space, and make something possible that wasn’t before.

Push the Frontier. Use Meta’s models to tackle challenges in software, robotics, manufacturing, energy, materials and beyond. Give a machine a new capability, accelerate a scientific experiment, or unlock a better way to understand and control a physical system. Show us what becomes possible when these models meet the real world.

Push the frontier requires working with real world physics systems, while Build for Your World requires strong domain knowledge which I have none in gaming.

I didn’t feel strongly connected to either, not because I don’t have any domain I’m expert in, but because getting started on Game Design has been on my mind for too long.

This causes the passion to die down after a few days when the core is successfully implemented, and adding more obstacles and moves felt like diminishing returns.

I’ve learned that the butterfly effect in hackathons is strong.
How creative and fitting the theme your idea is determines whether you have any chance of winning.
If the idea doesn’t stand out, no amount of effort matters, so measure twice cut once is extremely important, and especially when coding assistants can handle implementation fast.

Reducing focus on UI

At the beginning, I spent a lot of effort finding reference clips to get each movement correct.
Later I felt wrong and silly movement is part of the charm, as long as it doesn’t look violent or from a horror film.

I thought 2D was boring and a waste of the World Slicer feature, then later realized finding a single clearable lane cutting through a 3D world is just as interesting, and simplifies world navigation without losing the aesthetic which is covered by a player-controllable camera already.

The plain built-in obstacles looked unimpressive, but I later decided that could be part of the recognizable brand too.
A simple time of day dropdown to let the user choose Morning, Noon, Golden Hour, Dusk added to the vibes.
Another simple customization was letting the user apply their own wallpaper.

Upfront planning Move-Obstacle Interactions

The design of moves and their interactions with obstacles could have more thought put in.
I built obstacles one at a time and discovered the rules along the way. Animations were also created separately from obstacle design.
The simulator let a player grab a ledge when the hands were 2.4 m from the hips, but a real arm reaches about 1 m, so the animation had to cheat by blending.
These primitives came too late, and an interaction table is still missing.
If I started again, this would be first.

move primitives
obstacle primitives

With more time left to focus on the important features first and starting on UGC design earlier, I may have even allowed users to upload their moves.
It comes with privacy concerns, but the personalization gains are worth it.

Takeaways for your projects

  1. Let a referee judge the AI
    Keep a checker that doesn’t trust the AI’s output. Mine was the simulator, and nothing unplayable reached players. Yours might be a test suite, a type checker or a schema.
  2. Move up the ladder as agents speed up
    Decide what you will stop reading, and keep one level you always check.
  3. Identify your primitives and their interactions early
    List every pairing of your two core things, and fail the build on an empty cell to prevent designing yourself into a corner. For me it was moves × obstacles. For you it could be roles × actions.
  4. Count the cost of “share”
    Every shared thing needs four answers: where it lives, who sees it, when it expires and who pays.
  5. Choose a platform for your test loop
    The browser gave me instant playtests and a link anyone could open.

Hackathon Experience

This last part is about how the hackathon ran, what judges said and what I think matters.

How it was run

  • Who: Cerebral Valley organized it for Meta, with Modal, Baseten and Fireworks as partners.
  • Numbers: Meta gave $150 of credits to all 20,000 selected participants, out of 33,979 applications. The partners asked for an extra application form and picked 1,000–2,000 projects out of 5,367 submitted.
  • Rules: the written rules were simple, but organizers added many extra preferences in Discord threads. I wish these were public, because some participants may not use Discord at all.
    For example, all models used in live runs had to be Meta models, and the demo had to show a live call of Meta tools, ideally with logs.
  • Moderation: organizers removed abusive people from the server effectively. A Discord bot answered most questions, and repeated prompting was handed to humans.

The community

  • Participant initiatives helped everyone. One project scraped the Discord for GitHub links, which worked because people were spamming self-promotion. Another scraped the hackathon gallery after the submission date. Both are valuable: the first includes projects that failed to submit, and the second organizes each project into three parts, a GitHub link, a demo video and a project description.
  • The people: most participants were generous and glad to hear engagement on their ideas. A few sent unfriendly messages, one even calling me a bot, and the organizers removed them in the end. As in any online forum, that was to be expected.
  • Talking to others taught me development processes and inspired me with their ingenuity. I still see no reason to do hackathons in a group, though that may change if I find matching visions.
  • Extra servers: some participants built Discord servers that gather participants and VCs, so projects that did not win still get some visibility.
  • Too many posts were self-promotion. Many read as “look at my amazing project” instead of “I learned this, here is how I did it, and you can use it too”. I offered a spam mitigation plan to the Cerebral Valley Discord bot and got no response.
Spam mitigation plan

Judging

Seven judges gave live feedback (recording) and noted a few preferences. Below is what the judges said, some of it about other teams’ projects, and what I took from each comment. The quotes are the judges’ words, not my verdict on any team.

  • “Data collection potential.” I considered this in my design: we could collect data on people interacting with obstacles, but I scoped it out for time. Robotics research is mostly about simulated human bodies moving by themselves, with less work on humans interacting with objects. At the start I also planned the whole Worms World Party gadget list, but dropped it when I realized no model knows how to generate motion for a human on a pogo stick, since most models are trained with feet on the ground.
  • “Human validation.” Steps in a process should not blindly depend on AI, so there must be a checking mechanism. In my project, the simulator checks Muse Spark’s suggested course design.
  • “Generalized control surfaces, physical and personal AI, accessibility, custom interfaces.” There is a tradeoff here: for accessibility, keyboard and mouse in a browser are the easiest. I did not want to buy a Quest just for a VR or AR project in this hackathon, and there are other Meta hackathons for that. So I understand why other participants comment that robotics and VR winners are not as high-impact as other projects.
  • “Finetuned model, accepted security disclosures and fixes during the hackathon.” A great learning point: impact does not have to come only after submission. I tried to show this by tracking usage statistics on my courses page.
  • “Strong ecosystem, social competition.” I considered this too, with a leaderboard and community-made obstacles and characters. It opened the can of worms that is user-generated content, which I will not fully appreciate until it scales.
  • Judges on ORCA (Startup track): “Impressive CAD built for the demo.” I agree it is a great effort, and it shows the advantage of domain knowledge: someone must have used CAD before to know what good CAD looks like. A vibe coder with zero knowledge can make the UI, but understanding the UX, edge cases, pain points and what to highlight takes time.
  • Judges on Kroonen AI: “Clear explanations of hard ML research, not clear how to translate to a startup.” My takeaway is that research projects carry more risk than product projects at a hackathon. I feel that clearly explaining the product and its impact would complete such a demo.
  • “Show human-in-the-loop, scope of problem, a clear model and pipeline to improve.” The emphasis is not on offloading everything to agents, but on humans collaborating in creation. I would like to see how humans bring themselves into the loop in future.

My overall thoughts

On how prizes are judged:

  • Judges may lack domain knowledge in hardware, ML, construction, biology and other fields, so some features and problem statements get under-appreciated.
  • I wish prizes were spread over more winners, with projects competing within tracks and domains instead of one single mix, and with recognition given more broadly.
  • A prize for the best reproducible development process would have huge impact, because it pushes authors to document skills that transfer to more builders.
  • Judging deserves more time (Google takes 4–6 weeks) instead of being rushed into 5 days.

On waiting for results: it is hard, and many people were disappointed, as happens at any hackathon.
Some asked for a ranking of non-winners or a certificate of participation, and that would be a kind addition for next time.
What helped me was that the rules said up front that most entries would not win, however much effort they put in or how good the project is.
I treated the 10 days as the prize. It is closer to a lottery where effort improves the odds, but takes far more effort than a lottery ticket, and most of that effort is wasted unless you keep building or extract lessons that transfer.
Some participants felt their demo was clearly better than the winners’, which is a natural feeling after that much work.

What I noticed in the winners and the judges’ comments. I was not a judge, so this is a pattern I saw, not a rule.

What I did not see predict much:

  • hackathon participation history (the most creative award went to a first-time participant)
  • coding skill
  • commit counts
  • the number of repos on GitHub

What I did see in winners and judge comments:

  • A unique idea with huge potential for impact, from a well-understood problem statement
  • Production-ready, working features consistent with the demo
  • Exhibiting the organizer’s tools and fitting the theme (hackathons are largely marketing drives and test beds for organizers)

Winners

Indie track

Startup track

Special prizes

  • Most Viral ($20,000) — Adrian
  • Best Build on Meta Open Weights ($10,000) — Tessa
  • Best Agentic Use-Case ($5,000) — oqed
  • Best Creative Build ($5,000) — Team Synthexis
Bonus Prizes

Memorable projects

I commented on the ones I found unique and could add experience to. If I were a judge, I would have pushed for these to win something.

  1. LittleTake — 3D scene to video
  2. Paper Tour — Explaining any paper
  3. Ask-Y — Explaining thoughts
  4. Champt — Location-based chat
  5. Amanuensis — Music notation editor
  6. Questory — Outdoor puzzle game
  7. Crew Sync — Dance analysis
  8. Firsthand — Teaching any hands-on skill
  9. MyPaddy — Personal AI that processes various input types

Skills I gained

Reviewing 100+ projects taught me nearly as much as building my own. This is what I gained from my own project and reviews

  1. Much better appreciation of considerations in database design, UX, game design, UGC and their interactions
  2. Demo storyboarding and AI-generated media
  3. Multi-agent coding assistance across multiple infrastructure providers, project management, and Cloudflare deployment
  4. An eye for impact, what makes a submission unique, which demos are underselling
  5. Lateral thinking, applying ideas across disconnected domains, swift execution
  6. Searching chat history with claude-code-transcripts and claude-transcript-viewer helped review lost ideas

What’s Next

Voice-based products
Voice is my strongest domain. I should be doing something amazing there.
Figuring out licensing would be a pain, but such barriers to entry also create defensible moats.
Research on duet voice separation is still immature, maybe I’ll do a PhD in that some day if I can align consumer laryngoscopy, voice training, and anatomy.

Itch.io
Building a game and getting people to play it are different skills.
Itch allows practicing the former with Game Jams, and the latter by designing at attractive homepage.
I also want to get more familiar with AR/VR.
Horizon Create is Meta’s upcoming program to build games on phones.

Final Words

In 10 days I went from never having made a game to a course anyone can open and race. Felix Rieseberg’s essay gave me four dials, and I turned all four up.

  • Speed: it needs the right direction measured well upfront, and the willingness to slow down at the important parts.
  • Altitude: it needs flexibility to dive deep into the problem instead of leaving it all to Claude’s taste.
  • Depth: it can eat your time if you do it for your own satisfaction and it doesn’t serve the product. You don’t need expert-level design if the bottleneck is elsewhere.
  • Range: it needs experience design and storytelling to tie it all together.

I would love to talk with anyone working on: game design for learning, running several coding agents at once, or voice and singing technology.
You can play ConquerCourse here, or connect on LinkedIn with intro if you have questions or feedback.

Appendix

Prompting Devlogs

Claude’s summary of pending tasks

Training human-on-the-loop thinking

Document where human contributions add value

Hub File in multi-agent costing more tokens than single agent

hub file problem part 1/3
hub file problem part 2/3
hub file problem part 3/3

Blind Tests of Motion- Kimodo (text-to-motion) vs MoCap of real humans

blind tests of motion

NKRO vs SOCD (Street Fighter)

N-Key Rollover (NKRO) is what makes leverless and keyboard play possible in the first place.
Without high rollover, diagonal blocks (Down + Back) plus multi-button attacks (EX moves or Drive Impact) would drop inputs.
However, because NKRO removes the physical guardrails of a joystick, Simultaneous Opposing Cardinal Directions (SOCD, pressing two opposite directional inputs at the same time) rules had to be invented to artificially re-impose the single-direction limits of an arcade lever so charge characters remain fair.

Storyboard Prompts

Scene 3: Build your course

Overlay: Choose your course
Start from the shibuya 3d slice, rotate around the editor, show the top view, click fit, then go back to 3d view.
Change the dropdown to the bulb and bench course, then click fit.
Duration: 8 seconds maximum. 1 second on each view.

Overlay: Add your objects
Click Add Pieces, show the default tab with Real objects (stay 1 second here), then half second each for next 7 tabs totalling max 4 seconds.
Add a canal railing to the map, move it somewhere weird, show that the simulator says no solution (highlight this). 4 seconds maximum

Overlay: Design partner to suggest fixes
Click Improve -> Ask AI for ideas, show simulator suggesting piece movements, highlight the teal outlines (4 seconds maximum, speed up video if Design partner is slow)

Overlay: Accept changes
Click apply, show simulator now says can clear (highlight this). 4 seconds maximum

Overlay: Add moves by tweaking obstacles
Click moves -> find ways to add missing moves -> Show it . Mouseover to highlight the suggested changes.
Close the design Partner, click Play this lane, natural transition to next scene.
Use the already prepared “Bench lane or bulb lane” course

Scene 4:
You judge the timings for all of these, go fast at places where we don’t have to wait.
Most of these use real timings.

1 smooth run start to end on bench lane or bulb lane course.
Overlay: Run your course
Start character running after ghost in the bulb and benches course.

Overlay: Choose your path (High or Low)
Run jump, and catch the pole during the jump, climb up the pole, pump 1 full circle and swing at least once, let go down onto bench, continue the run to finish

Overlay: Share your achievements
Enter MetaHackathon in Name field, click Publish, see the run enter leaderboard.
Highlight the new row in leaderboard. ()

Overlay: Challenge your friend, or take their challenge
Point at Copy link to challenge a friend.

Overlay: Watch yourself or the simulator to do better
Point at download your clip
Scroll down, click Watch the best line, watch the character finishing jumping through all and cut (watching is 6 seconds max)

Scene 5: Unleash your creativity
We showcase canon ball flying at us ideally with canon in view, coaster starting to go down from very steep angle, boarding and flying drone, doing pole vault, launching from trebuchet.
Each 2 seconds to show what we have

Scene 6: Learn the Basics
Start from the Dojo Gap Jump screen 2 seconds on The real obstacle default tab , click The idea (2 seconds on this)
Click “The exact formula” and drag the sliders to show graph changing (2 seconds).
Click rope swing tab (2 secs), stored energy tab (2 secs)

Scene 7: Go for Mastery
Start from the mindmap of the labs.
Mouseover each Pipelines card 1 second each so we see the edges updating.
Click Know the limits after the last second, ensure we see the yellow circle for click
In the Know the limits lab, Drag some cards across columns (3 seconds) then do 2 page down presses, with 2 second pause after each page down

Scene 8: Create your own Character
Start from training course , click characters on top right,
Type (character by character) ninja warrior, click make it.
After generation, click play as, rotate camera from side to front view full body, add other 10 characters running onto platform from behind, then all raised up from the game landing on a platform and spread out with ninja warrior in the middle, then do the final jumpshot in left right alternative, like what we did in promo-v2.mp4 (take ideas, don’t copy directly).

Overlay: Play now: https://conquercourse.pages.dev
Close with the logo and slogan


ConquerCourse: Building a Physics and Computer Science Ninja game was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.