July 20, 2026 · 8 min read
How we built Agent Runner with AI coding tools
How Agent Runner went from a 23-minute prototype to a finished game built with coding agents, source context, generated concepts, and hand-made art.
Agent Runner turns a familiar coding-agent problem into an arcade game. Your agent runs while its token budget drains. Context coins stop the burn, hallucinations make it lose direction, loops send it backwards, and rate limits stop progress.
The first playable version took 23 minutes to build. The finished game took several weeks.
ChatGPT, Claude Chat, Claude Code, image generation, Illustrator, Photoshop, and GitHits got the idea on screen quickly. Making it clear and worth playing still took direction, testing, source research, and a lot of manual work.
Start with the mechanic
The first prompt was written at 2:09 a.m. It described an 8-bit platformer with selectable agents, a draining token meter, context coins, GitHits tools, a “loop hole,” and one control: jump.
It was too much. ChatGPT helped cut the parts that did not support the idea. Google’s Dino game was the useful reference: one input and a loop anyone understands immediately.
The idea became one sentence:
Better context helps coding agents waste fewer tokens and fewer runs.
The concept translated directly into game mechanics:
| Product concept | Game mechanic |
|---|---|
| Token consumption | A counter that constantly drains |
| Better context | Coins and tools that preserve tokens |
| Hallucinations | The character loses direction |
| Repeated loops | The player is sent backwards |
| Rate limits | Progress stops while tokens keep draining |
The prototype had a one-day kill rule. If the mechanic was neither fun nor clear by the end of the day, we would stop.
The implementation brief was deliberately narrow:
BUILD:
- endless auto-run
- spacebar jump
- draining token meter
- context coins
- three obstacle types
- game over and restart
DO NOT ADD:
- menus or character selection
- powerups or achievements
- mobile support
- sound, particles, analytics, or backend
The exclusions mattered. Coding agents are good at adding plausible features. That is not useful when the question is whether one mechanic works.
From brief to playable build
ChatGPT suggested Vite, TypeScript, and Phaser 3. Before implementation, Claude Code reviewed the repository and used GitHits to check the stack against real projects and the site’s constraints.
Claude Code received the brief at 2:22 p.m. The game was playable at 2:45 p.m. The first pull request was open at 3:52 p.m.
A playable build made the idea cheap to test, but it was still a prototype.
Once the game was running, feedback focused on what the player should experience: freeze the world long enough to read a hallucination, make every obstacle jumpable, show how many tokens context saved, and make the loop look like a portal instead of a block.
The coding agent handled the implementation. We stayed responsible for what the game communicated.
The prototype nobody noticed
The first gray-box version was shared internally with a short explanation. Nobody replied.
It nearly ended there. After almost three weeks, work continued as a side project without blocking the main product roadmap.
The silence was useful, even if it was not encouraging. The mechanic worked, but the build still asked people to imagine the characters, world, tone, and connection to GitHits. It was testing an unfinished presentation as much as the idea itself.
The next version had to ask less of the audience’s imagination.
A repeatable build loop
As the game grew, one long implementation prompt stopped being reliable. The work settled into a shorter loop:
- Let Claude Code summarize the repository and its constraints.
- Use a chat model to challenge the next feature and write a brief.
- Review the brief against the repository and relevant open-source implementations.
- Change the plan when the source shows a better approach.
- Implement, test, and inspect the result in the browser.
- Play it, then decide what to change next.
The grounding instruction was simple:
Review the repo, but ground the planning with GitHits.
We used that checkpoint for framework integration, browser behavior, and decisions that would be expensive to reverse. Minor spacing and copy changes did not need it.
Generated concepts, hand-made assets
ChatGPT and Gemini explored character concepts, portraits, and the logo. Illustrator and Photoshop produced the final sprites. Claude Code supplied the technical constraints and integrated the assets.
The sprite sheets were drawn and refined by hand, with Mega Man sprites used as references for pose, proportion, and movement. Run cycles, silhouettes, palettes, coins, and obstacles all received a manual production pass.
Before drawing began, Claude Code produced an asset spec with frame sizes, hitboxes, and tolerances. That went straight onto the Illustrator artboard. Each finished asset was integrated and tested in the game before the next one was made.
Not every finished idea survived. A synthwave perspective grid was built twice and then removed because it fought the sideways movement. Parallax mountains worked better. Generated output was treated as a proposal, not something the game had to keep.
Where GitHits mattered
GitHits was used when a wrong assumption could quietly break the game or the site around it:
| Decision | What the source clarified |
|---|---|
| Character speed | Different speeds required distance-based spawning, not time-based spawning |
| Astro integration | Phaser needed clean mounting, teardown, and navigation inside a static site |
| Social cards | The server-side image pipeline had to fit the production architecture |
| Mobile support | Responsive sizing and touch input had to preserve reaction time and comparable scores |
| Escape navigation bug | The Phaser keyboard code was valid, so the fault was in browser behavior |
The Escape bug is a good example. Pressing Escape destroyed the game but left the browser on an empty route. GitHits confirmed that the Phaser keyboard pattern was correct. That ruled out the first theory and moved the investigation to the browser, where Escape can invoke “stop loading” and cancel navigation triggered by the same event. Preventing the default and deferring navigation fixed it.
GitHits did not write the feature. It helped remove the wrong explanation before more code was changed.
Turning the prototype into a product
The public version added music, tests, mobile input, responsive layout, analytics, reliable teardown, sharing, and a result screen that connected the score back to GitHits.
The result screen showed tokens saved through context coins, Code Navigation, and Package Intelligence. A good run ended with “TOKENS WELL SPENT” and a real next step:
npx githits@latest init
Social sharing used a dynamic Open Graph scorecard. The Astro site is static, so an Azure Function generates the image with Satori and resvg. That architecture was checked with GitHits before implementation.
Adding a touch handler was not enough for mobile. A narrower screen reduced reaction time, so the game zooms out slightly and warns about obstacles earlier. The controls use actions such as JUMP, START, and EXIT instead of exposing keyboard-specific input.
When this version was shared internally, people responded immediately. The mechanic was better, but the larger change was that the intended experience was finally visible.
What happened after launch
Agent Runner was published at githits.com/agent-runner and shared with relevant communities.
On June 23 and 24, GitHits recorded its two highest daily unique visitor counts at the time: 175 and 222. Most of the new traffic came from Reddit and landed on the game.
We cannot tell how many visitors understood GitHits from those numbers alone. We can see that the game reached people who had not arrived through the usual product explanation.
What we learned
The fast part was turning the brief into code. The slower work made that code communicate the idea: cutting features, testing the mechanic, grounding technical decisions, drawing the art, rejecting weak output, and preparing the game for real users.
The tools worked best with clear roles. Chat models challenged the brief. Claude Code implemented and integrated. GitHits checked assumptions against source. Image generation explored directions. Illustrator and Photoshop produced the final assets.
For another project, we would follow the same order: reduce the idea, build the smallest test, play it, check important assumptions, and keep working until the result explains itself.
AI coding tools made the first 23 minutes possible. They did not replace the weeks of judgment that turned the prototype into Agent Runner.
Play GitHits Agent Runner or connect GitHits to your own coding agent:
npx githits@latest init