Watch Fable Turn 628 Million Tokens Into a Professional Game

Fable in the Lab: From Design Concept to a Finished, Award-Worthy Game

In this hands-on lab session, Matt Maher works live to take a mobile Spades card game all the way from a design concept to a finished, high-polish product. The workflow chains together three tools: Claude Design to generate the visual concept, Claude Code (via the Claude desktop app) to orchestrate the build, and the Fable model, running on its highest "extra" effort setting, to actually construct the game. The theme running through the whole demo: you do not have to specify every feature to get a complete, professional result. You just have to orient the agent at an objective level and let it evaluate its own work.

The Goal: One or Two Shots to a Polished Product

Matt frames the session as an experiment in pushing these tools as far as they can go. The ambition is to set the build up so that it reaches a final, high-fidelity product in roughly a "one shot or maybe a two shot" run, with minimal hand-holding along the way. The end state he wants is not a rough prototype but something that feels like a class-A, shippable, "win awards with it" game.

Starting in Claude Design

The design phase happens in Claude Design, reachable at claude.ai/design or as a panel inside the Claude desktop application. Clicking the button opens a new Claude Design panel identical to the web experience:

• You describe what you want to design and it generates real design assets, from wireframes up to very high-fidelity screens.
• The designs can be shared directly back into Claude Code, which is the key to the whole workflow.
• For this build, Matt requested a full mobile Spades game: a traditional four-player card game reimagined for a phone.

The generated design covers a lot of moving parts and screens: dealing, bidding, viewing your hand, seeing your opponents, landscape mode, reacting to other players' actions, in-game communication (it is meant to be multiplayer), plus win/lose screens, score screens, settings, and how-to-play. Crucially, Matt did not hand-define every one of these screens. He asked for a lot of sections and let the tool fill in the detail.

Key Idea: Orient the Agent at an Objective Level

The central lesson of the video: "You don't have to know all of this to be able to get all of this." Rather than enumerating every feature, you orient the agent toward an objective, and it works out the pieces. This applies to both the design request and the build request. The design prompt was small, but a few deliberate word choices did a lot of work.

What Went Into the Design Request

The design prompt was short but pointed. The phrases that made the difference:

• An "incredibly high fidelity, very clean, extremely graphically intense and animated application" — being explicit and forceful about the look and feel mattered more than anything else.
• It should feel fun and playful, not childish, and specifically not a poker / smoky-back-room card vibe. That single constraint steered the aesthetic toward bright, bouncy "blobs dancing around" instead of a serious gambling look.

Sharing the Design Into Claude Code

Once the design exists, Matt shares it into the build environment. From Claude Design, use Share → More formats and apps. Two paths both work equally well:

1. Send to Claude Code via MCP — copy the provided prompt, which references an MCP that Claude Code can use to log into the design system and pull the files directly.
2. Download a ZIP — download the design assets, drop them into the project (Matt creates a docs/Designs folder), then hand the copied prompt to Claude Code and point it at the designs folder.

He deliberately avoids sharing as a PDF, because the goal is to capture the actual design assets, not a flattened document. Everything gets built into a fresh, empty spades project folder that also holds a small intent/placeholder document capturing the original request.

Kicking Off the Build with /goal and Fable

Back in Claude Code, Matt starts the build with the /goal command and runs it with Fable on "extra". He instructs it to build from a prepared build request file that contains both a technical build requirement and the design assets. His actual kickoff prompt: "build the builds request file until entirely complete. We want to win awards with this." He notes the run will likely take close to an hour, so he lets Fable build in the background while narrating.

Why /goal Matters: Objective-Level, Self-Evaluating Builds

The reason for /goal is the heart of the technique. Instead of stopping at the first pass, /goal tells the agent to continue evaluating its own work against a success statement until it hits the mark:

• It is best for open-ended, objective-level builds: "get to this point," "construct this system," "build this thing."
• You pair the objective with a measurement / evaluation statement: the right metrics, no remaining defects, or acceptance by some set of requirements.
• The agent keeps building, then re-reads its evaluation statement to ask itself: did I really hit what was asked? Is it genuinely high quality?
• Matt notes /goal works even better when you combine explicit build requirements with a looser quality goal. Here the loose goal was simply: make it high fidelity, class-A, playable, award-worthy.

The takeaway is that a "very loose set of goals" still works, as long as the objective and the way to measure success are both stated. The agent fills the gap between them.

Two Requests, Two Purposes

Matt is careful to distinguish two different prompts in the pipeline:

• The design request — given to Claude Design purely to produce the cool visual concepts.
• The build request — given to the build engine (Fable via Claude Code), combining technical requirements and the design assets so it can execute.

Practical Takeaways

• Design in Claude Design, build in Claude Code, execute with Fable. The design-to-code handoff via Share (MCP or ZIP) is what makes the concept actionable.
• Do not over-specify. Orient the agent at an objective level and let it derive the screens and features.
• Be forceful and specific about look and feel. Words like "high fidelity, clean, graphically intense, animated, fun not childish" shape the entire aesthetic.
• Use /goal for open-ended builds so the agent self-evaluates against a success statement instead of quitting after the first pass.
• Pair explicit build requirements with a loose quality goal ("win awards with this") to get both correctness and polish.
• Let long builds run in the background. A high-effort Fable run on a full game can take close to an hour.

Notable Quotes

"You don't have to know all of this to be able to get all of this. You just have to be able to orient your agent at an objective level."

"Build the builds request file until entirely complete. We want to win awards with this."

"That's a very loose set of goals, but it absolutely does work. You'll see that by the end."