From a Tweet to a Playable 3D Game: What Claude Fable 5 Built in One Session

ByTejinder Singh
Reading Time: 4 minutes

Simon Willison used a single prompt and two old images to have Claude Fable 5 autonomously build a complete 3D browser game — Raccoon Heist — with animated characters, sound, mobile touch controls, and automated testing across seven commits. The experiment demonstrates what autonomous AI-assisted development looks like today, and what it could mean for non-technical professionals who need interactive digital tools without a development team.

A Four-Year-Old Tweet Becomes a Playable Game

In August 2022, developer and researcher Simon Willison posted a tweet containing a short product description generated by GPT-3 and some rough concept art from DALL-E, imagining a game called Raccoon Heist — a caper where a team of masked raccoons rob suburban houses under cover of night. It was a fun experiment, nothing more.

Four years later, on the anniversary of that tweet, Willison decided to run a different experiment: could Claude Fable 5, running inside Claude Code for web, turn that old tweet — images and all — into a complete, playable, mobile-friendly browser game, with no further input from a human designer?

According to Simon Willison’s writeup, the answer is: yes, and impressively so.

What Actually Happened

Willison fed Fable 5 two images from the original 2022 tweet, along with a single prompt written on his phone. He told the model to build a 3D browser game, make it mobile-friendly, use an OpenAI API key to generate textures via the gpt-image-2 image model, commit to GitHub as often as possible so he could preview progress, and — critically — work independently without asking for any further design decisions.

That last instruction is worth pausing on. Willison was not iterating with the model. He gave it a direction and stepped back. What followed was an autonomous multi-step build process.

According to Willison’s analysis, Fable 5 took the following steps on its own:

  1. 1. Created an index page and vendored a local copy of Three.js (the 3D graphics library), avoiding any dependency on a CDN.
  2. 2. Wrote a Python script called gen_textures.py to generate all seven ground and wall textures using gpt-image-2, then spot-checked the results to verify they looked correct.
  3. 3. Built the first playable version of the game, then opened a pre-installed Chromium browser using Playwright (a testing tool) to take screenshots of its own work — on both desktop and mobile screen widths.
  4. 4. Noticed a bug on mobile (the raccoon character was invisible at small screen sizes) and fixed it before continuing.
  5. 5. Generated a title screen using a detailed image prompt it wrote itself, describing a low-poly raccoon in a burglar mask carrying a gold coin under a full moon.
  6. 6. Added a guard dog as a new game mechanic: a low-poly hound that tracks the player by scent rather than line of sight, starting from night 3 of the game.
  7. 7. Wrote automated Playwright tests for the dog mechanic, simulating a player walking near the dog and verifying the chase-and-catch behaviour worked correctly.
  8. 8. Declared itself done after seven commits, with the game verified across desktop, portrait-phone, and landscape-phone viewports.

The finished game — which you can play via the link in Willison’s post — includes coin and loot collection, multiple guard types, a procedurally generated WebAudio jazz soundtrack (no audio files, just code), a touch joystick for mobile, win rankings from ‘Trash Panda’ to ‘Master of Disguise,’ and a high score saved to your browser’s local storage.

Why This Matters for Non-Technical Professionals

You may not be building games. But the workflow Willison describes is directly applicable to a wide range of professional tasks that currently require a developer.

Consider a training and development manager at a mid-sized manufacturing company in Pune. Her team needs an interactive browser-based quiz for factory floor safety compliance — something employees can open on their phones without downloading an app. Today, that requires briefing a developer, waiting for a sprint slot, reviewing builds, and going through multiple rounds of feedback. The bill for even a simple interactive tool can run into ₹80,000–₹1,50,000 or more, depending on the agency.

The Raccoon Heist experiment suggests a different possibility. With Claude Fable 5 running inside Claude Code, you could describe what you want — the questions, the scoring rules, the mobile layout — provide a rough sketch or a reference screenshot, and let the model build, test, and commit a working version autonomously. Willison’s session produced a functioning multi-level game with animated characters, sound, and automated test coverage. A compliance quiz is a significantly simpler target.

The key phrase in Willison’s prompt is instructive: “Work independently — do not ask me to make any further design decisions.” That is the shift. You are not a developer’s assistant, feeding requirements into a ticketing system. You are the person who defines what matters, and the model handles the rest.

The GitHub Pages Workflow: A Practical Detail

One specific technique Willison describes is worth understanding, because it solves a real frustration with Claude Code for web: you cannot easily preview what the model is building while it is still working.

His workaround uses GitHub Pages. The process, as described in his writeup:

  • Create a new GitHub repository for the project.
  • Start a Claude Code session and instruct the model to commit an index.html page as early as possible.
  • In the repository settings, enable GitHub Pages and point it at the branch Claude is working on.
  • Within about 30 seconds of each commit, the latest version of the project is live at a public URL.

This means you can watch the game (or the interactive quiz, or the data dashboard) take shape in real time in your browser, on a separate device, while Claude continues building. For a non-technical professional, this is the equivalent of watching a contractor work on-site rather than waiting for a handover.

Willison notes that if you use a private repository, the published GitHub Pages content is still accessible to anyone who can guess the URL — worth keeping in mind if your project contains sensitive information.

What Fable 5 Cannot Do (Yet)

Willison’s experiment is genuinely impressive, but his writeup also surfaces real limitations that you should understand before forming expectations.

What to Watch For Next

The Raccoon Heist experiment is a useful benchmark for what ‘one-shotting’ a project means with Fable 5 today. The model can architect, build, test, debug, and ship a working browser application from a natural-language description and a couple of images — autonomously, across multiple commits, in a single session.

If you want to start exploring this direction, Willison’s full writeup at simonwillison.net includes the exact prompt he used, a link to the shared Claude Code session transcript, and the GitHub repository with all the generated code. Reading the transcript — where you can see every decision the model made and why — is the most educational part of the whole exercise.

The question worth asking now is not whether Claude can build something. It clearly can. The question is what you would build if a capable, autonomous developer were waiting on your description.

Related stories