Fable 5 AI transforms the classic Snake game with a "Make it Better" prompt

iconMetaEra
Share
AI summary iconSummary
AI and crypto news highlights a new project announcement: Ethan Mollick used Fable 5 to reinvent the classic Snake game with the prompt “Make it better.” The AI iteratively refined the gameplay, testing its ability to interpret vague feedback and maintain consistency. The demo illustrates a shift in AI programming from initial generation to long-term project evolution.
Ethan Mollick had Fable create a "self-aware" Snake game in which the snake gradually becomes aware that it exists within a game and alters its gameplay. The key experiment lies in providing only one ambiguous feedback: "Make it better," requiring the AI to translate it into actionable engineering changes. This tests the AI’s ability for iterative refinement: maintaining project consistency across long contexts, interpreting ambiguous feedback, making planning judgments, and distinguishing between hard, code-level feedback and soft, experience-level feedback. The significance of the Fable demo is that it shifts the focus of AI programming from "generating the first version" to "maintaining the Nth version"—a core engineering challenge currently faced by AI agents.

Author and source: Leiphone

A small game containing engineering interview questions for AI agents.

At which apple does the snake begin to wonder why it can only move up, down, left, or right?

This sounds like a cold joke, but Ethan Mollick’s recent AI experiment began with essentially this question.

He asked Fable to create a "self-aware Snake game": the snake starts as the classic Snake, moving, eating, growing longer, and dying upon hitting a wall.

But as the game progresses, it gradually becomes aware that it exists within a game, that the rules are artificially set, and that a player is controlling it. Then, the game begins to transform, evolving its gameplay from Snake into different genres such as RTS, farm simulation, and narrative exploration.

More interestingly, Mollick didn’t provide a detailed design document like a traditional game producer. He didn’t specify exactly how to revise the UI, design levels, or balance mechanics. Often, he simply offered one sentence: “Make it better.”

In traditional software development, this wouldn’t even qualify as a requirement—it doesn’t specify what needs to be changed or what constitutes success. But for an AI agent, this is precisely the challenge: it must translate vague feedback into actionable engineering steps.

This is also the part of the Fable demo that truly deserves analysis.

Generating a Snake alone isn't technically challenging. The real difficulty lies in whether, after the first version exists, the AI can continuously modify the existing system rather than regenerating an entirely new one in each round.

With just “Make it better,” Fable 5 turned Snake into a rebellious persona.

From prompt to loop

In the past, many AI programming tasks were more like one-time generation: a person states the requirement, and the model returns code. The key in this model is the prompt—how clearly the person articulates the requirement.

However, the Fable case is more akin to a loop. A loop does not end after the model provides a single response; instead, it enters a continuous process: first understanding the current project, then proposing modifications, followed by updating the code, running it, checking the results, and moving on to the next round.

This change will shift the technical challenges.

When generating code all at once, AI can organize it in its own way; as long as it runs at the end, whether the structure is suitable for long-term maintenance won't immediately become apparent. However, with continuous modifications, each new change must be attached to the existing system, and issues such as code structure, module boundaries, and state management quickly surface.

In a game project, core gameplay, state transitions, narrative progression, and visual feedback often influence one another. If the AI doesn’t understand the relationships between these elements, it may disrupt the original logic while adding a new effect. In the short term, content may increase—but after multiple iterations, the system becomes increasingly difficult to maintain.

So, what was tested in this demo with Fable wasn't just its ability to write code, but its capacity to maintain project continuity through multiple rounds of revisions.

This continuity largely falls across several levels: it must remember that the core narrative of the game remains “the snake gradually becoming aware that it is within the game”; it must distinguish which parts of the current code handle core gameplay, which manage state changes, and which drive narrative progression; it must also control the scope of changes in each iteration to avoid rewriting excessive legacy logic for a single localized effect.

This is the difference between agentic coding and conventional code generation. Conventional code generation is like solving a problem; agentic coding is like entering an already running project, reading, modifying, and validating as you go.

Precisely because it enters a continuously running project, vague feedback like "make it better" becomes an engineering issue.

What makes "Make it better" difficult?

More precisely, "Make it better" is not a specific instruction but an open-ended evaluation.

Clear instructions are easier to handle. For example, “add a start button,” “fix the collision error,” or “slow down the speed” can all be directly mapped to code changes. But “make it better” is not this clear.

It could refer to smoother gameplay, more natural storytelling, or greater system stability. AI cannot directly jump to writing code; instead, it must first determine which category the current version’s issue belongs to. This step may seem like a product judgment, but it directly impacts engineering implementation.

If the issue lies in the interaction layer, changes may affect input responses and feedback timing; if it lies in the state layer, changes may impact stage transitions and rule management; if it lies in the structural layer, adding more features may only make the system more chaotic—refactoring the code first will be more stable.

In other words, before vague feedback enters the code, it must undergo task decomposition: what problem is this round meant to solve, what scope should the changes be limited to, which existing logic must not be broken, and how will we verify that no new issues have been introduced after the changes?

What challenges the Agent here is the "planning layer." While conventional code completion focuses solely on how to write the next line of code, the Agent must take an additional step: deciding whether to write at all, where to write, and to what extent.

Without this step, "Make it better" is easily interpreted as "add more content." More content doesn't necessarily mean the system has improved. For this demo, what's more critical is whether Fable can turn vague feedback into a set of manageable, actionable modifications.

This naturally leads to the next question: The longer a project evolves, the more historical information accumulates—how does the model know what to keep?

After entering the multiple revision stages, the context will become increasingly longer.

The longer a project runs, the more information the model needs to process. Code structure, historical changes, current goals, past issues, and temporary solutions all enter the context. Longer contexts are certainly helpful, as they allow the model to see more historical information.

If the model simply adds more content to the context without distinguishing which information remains important, the project will still spiral out of control. It may remember what was added in the previous round but forget the original intent of the game; it may solve the immediate problem yet make future modifications more difficult.

In this demo, Fable must retain not all details, but several stable constraints: the game must still preserve the core recognizability of Snake; "self-awareness" must not remain confined to dialogue but must influence rules and interactions; new gameplay elements must not disrupt the original core loop; and even after multiple iterations, the code must remain maintainable.

These constraints will not be re-reminded by the user each time. The model must compress historical information into a set of working rules and continue using them in subsequent modifications.

This is the difference between long context and long-range capability. Long context addresses “how much the model can see”; long-range capability deals with “whether the model can extract key insights from this information and consistently adhere to them in subsequent responses.”

For continuous development, the latter is closer to the real challenge. However, even if the model can remember the main logic and control structures, another layer of evaluation is still needed to determine whether the project has truly improved.

Because feedback at the code level and feedback at the experience level are not the same thing.

Just because the code runs doesn't mean the iteration is effective.

In software development, there is a type of feedback that is clear: whether the code has errors, whether the build succeeds, and whether the page loads. All of these can be checked using tools.

But Mollick’s demo also received another type of feedback: whether the experience had improved. This is harder to judge automatically.

Successful program execution only indicates that it has passed the minimum engineering checks. It does not indicate whether the rhythm feels more natural, whether new mechanisms serve the theme, or whether the system has become clearer after multiple rounds of revisions.

This is also one of the challenges for AI agents in creative development: hard feedback is clear, while soft feedback is ambiguous.

Hard feedback comes from code and tools, such as error messages, tests, and build logs. Soft feedback comes from experience and judgment, such as whether players understand rule changes, whether gameplay supports the narrative, and whether complexity remains within manageable limits.

If an agent relies solely on hard feedback, it will tend to focus on easily verifiable tasks, such as fixing bugs, polishing interfaces, or adding features. However, “make it better” often isn’t just about adding features—it’s about making the relationships between existing components flow more smoothly.

Therefore, a more effective iterative approach is for each round of changes to clearly articulate what problem it solves—rather than vaguely stating “enhanced experience”—by specifying whether this round focuses on adjusting interaction feedback, state transitions, narrative pacing, or code structure.

This evaluation ability directly impacts the quality of AI-driven project revisions. The clearer the judgment, the easier it is to contain the scope of changes; the vaguer the judgment, the more likely the code will become bloated.

At this point, the technical signal from Fable’s demo is fairly clear: it’s not just generating the first version, but attempting to handle the Nth round of revisions.

From generating the first version to maintaining the Nth version

The significance of the Fable case lies not in proving that AI can make games, but in shifting the focus of AI programming from "generating the first version" to "maintaining the Nth version."

The first version of code is usually not the most challenging. In real development, the tougher part comes later: how to adapt when requirements change, how to add features without creating chaos, how to fix bugs without introducing new ones, and how to maintain a clear structure after multiple iterations.

Mollick’s “Make it better” perfectly encapsulates this issue in a small demo.

It presents AI not with a clear set of requirements, but with a constantly shifting goal. Fable must assess in each round: whether the goal has drifted, whether the structure has become disordered, whether the changes are worth keeping, and where to proceed next.

What’s most interesting about this snake isn’t that it “doubts its existence,” but that it shows us AI agents are approaching a more realistic development scenario: not just understanding a single prompt and delivering a piece of code, but continuously understanding, modifying, validating, and moving forward within an existing system.

From this perspective, Fable’s demo is more like a small stress test: can AI effectively move the project forward when faced with ambiguous feedback, long context, multiple rounds of revisions, and subjective experience judgments?

This may be the most important meaning of "Make it better."

Reference link: https://x.com/emollick/status/2069207757199200408

With just “Make it better,” Fable 5 turned Snake into a rebellious persona.

With just “Make it better,” Fable 5 turned Snake into a rebellious persona.

Disclaimer: The information on this page may have been obtained from third parties and does not necessarily reflect the views or opinions of KuCoin. This content is provided for general informational purposes only, without any representation or warranty of any kind, nor shall it be construed as financial or investment advice. KuCoin shall not be liable for any errors or omissions, or for any outcomes resulting from the use of this information. Investments in digital assets can be risky. Please carefully evaluate the risks of a product and your risk tolerance based on your own financial circumstances. For more information, please refer to our Terms of Use and Risk Disclosure.