←Back/How I AI
How I AI

Fable 5.2 review: creative enough to build a typewriter, still bad at web design

Claire Vo tests Fable 5.2 on animated marketing videos, furniture assembly, a bug-defense game, a messy ChatPRD pipeline, and a 3D typewriter—and explains where she still prefers Opus 5.5.

Claire Vo's profile picture

Claire Vo

November 16, 2026·9 min read

Episode chapters

  1. 0:00Why Claire changed her mind about ClaudeFirst impressions of Fable 5.2, its relationship to Opus 5.5, and the strengths and limitations Claire observed.
  2. 7:02From a tweet to animated brand charactersA software-factory tweet and CXO.dev brand guidelines become an animated video with custom invader-bot sprites.
  3. 11:09Furniture instructions and a bug-defense gameFable reconstructs assembly instructions from floor photos and turns branded characters into an engineering-themed game.
  4. 14:58Real architecture work—and failed web designsClaire assesses an unfinished ChatPRD pipeline migration and shows why she would not trust Fable with unguided web design.
  5. 17:56Inside Claire’s 3D typewriterA working typewriter expands into an atmospheric writing environment with timers, music, multiple scenes, and printable pages.
  6. 22:38Benchmark preview, availability, and final verdictEarly task timings, planned model comparisons, and Claire’s assessment of where Fable belongs in her toolkit.
Episode outline

Fable 5.2 built me a working 3D typewriter. You can click the keys or use your keyboard, turn on rain, start a writing timer, and switch to a Y2K computer that prints your words onto a virtual printer. It also designed a browser homepage so ugly that I would not trust it to design a website unsupervised.

That is the useful tension in this model: creative range and visual taste are different capabilities.

I spent a couple of days building with Fable 5.2 before recording this first look. I came in skeptical. The original Fable and Opus 5 could get work done, but I found them unpleasant to work with. Intelligence did not make them intelligible. I had moved much of my coding to Codex, partly because I preferred its desktop experience, browser use, and computer use.

Now I’m back to doing most of my coding in Claude Code, mostly with Opus 5.5. Fable 5.2 adds something I genuinely want: fast, autonomous work with enough creative initiative to surprise me. But the examples matter more than that endorsement—and some are much more conclusive than others.

A typewriter worth using, with a caveat about “one shot”

The project that won me over started with someone else’s work. I saw Guillermo Rauch’s 3D record player, loved the rendering and detail, and was inspired by the fact that he shared the source code. I pointed Fable 5.2 at a related but different idea: a functioning 3D typewriter.

The result was an interactive writing environment, rather than a picture of a typewriter. The keyboard worked through both mouse clicks and physical keyboard input. You could zoom in, backspace, and type over existing text. A correction feature attempted to cover a mistake and retype it, although that did not quite work correctly in the demonstration.

Then there was the environment around it: music, rain, a coffee cup, writing prompts, and hourglasses that start 15-minute or 30-minute timers. I integrated Guillermo’s record player, with selectable radio stations. Different scenes put the writing surface on a train, beside an oil lamp, or on handwritten pages. My favorite was the Y2K computer, with green and amber screen options and a printer that added pages to a stack. I could reopen the pages, save them, and copy the text.

the Y2K writing scene with green and amber screen options and its virtual printer

I called this a one-shot result in the episode, but the distinction matters: the keyboard was the one-shot result. I also made tweaks and kept asking for new features. The complete, multi-scene application was not evidence that one prompt produced a finished product without iteration.

The show notes link to typed.page. What I would copy from this experiment is the starting point: take a specific interaction you want to spend time with, give the model a concrete reference, and test whether the interaction actually works. That is my practical takeaway, not a verbatim prompt from the session. The broken correction behavior is exactly why a beautiful demo still needs hands-on testing.

A tweet became animation instead of moving slides

Before this test, I had been using HyperFrames with Opus 5.5 to turn customer meeting notes, tweets, and other material into videos. That had already changed how I approached product marketing. But the output often felt like animated Google Slides or PowerPoints.

For the Fable test, I supplied a tweet about software factories and our CXO.dev brand guidelines. The request was straightforward: “Make this tweet a video.” I did not provide a storyboard or creative direction beyond the brand book.

The video built a story around an engineering organization deciding it needed a software factory. A team gets a quarter to build it. The plan looks beautiful on a slide. Then the factory starts running: the repository is not ready, checks are slow, and nobody has been trained. Instead of presenting those points as moving text, the video used our space-invader-style characters, a bug factory, and other animated scenes.

There was back-and-forth. This was not a claim that the first generation was perfect. What impressed me was how much visual storytelling Fable supplied independently.

The most useful intermediate artifact was a set of sprites. Our invader characters, originally made by Jamie Gannon, existed as static images on the CXO website. Previous attempts with other models mostly made them wiggle across the screen. Fable created poses and movement for walking, cheering, and jumping. These are abstract little objects; inventing convincing motion for them requires more than sliding an image from left to right.

A detailed view of 'Invader-bot' pixel art sprites showcasing various character poses within a development or AI-assisted interface.

I was impressed enough to add “animate the invader bots” to the How I AI bench. The timing shown later in the episode was 16 minutes for that task. That is a useful observed result, though it is not a controlled comparison against every other model.

For someone copying this workflow, I would preserve the input combination: one clear source argument plus a real brand guide and existing assets. Then review the motion itself. If the characters merely drift around while captions change, you have made a different artifact from the one demonstrated here.

The geometry test was a pile of furniture on my floor

The less glamorous test may have been the more convincing one.

A furniture delivery arrived with an open bag of screws, 25 pieces of wood, and no instructions. I had already tried to get other models to produce assembly instructions, and every model I tried failed.

The inputs for Fable 5.2 were low-resolution photos of the flat-pack pieces on my floor, including Chinese-language labels. It produced both a diagram and step-by-step assembly guidance.

Assembly order was the important part. Anyone who has put together complicated flat-pack furniture knows that a plausible final shape is insufficient. Install something too early and you can block access to a connection you still need to make.

I followed the instructions with the person who came to assemble the furniture. The order worked, and the piece is now assembled in my house. That gives this example a kind of validation the prettier demos do not have: we used the output to complete the physical task.

This is still one furniture assembly, not proof of general mechanical reliability. My advice for adapting it would be to photograph labels and connection points clearly, ask for an ordered sequence, and check each step against the actual parts before proceeding. Those are usability recommendations; the demonstrated result was that Fable recovered workable instructions from the imperfect photos I already had.

I also extended the CXO animation work into a bug factory game. The request was to make a game about fighting bugs using our branded space invaders. Fable supplied mechanics tied to engineering trade-offs: more agents could help catch bugs, but missed bugs had consequences; protected time and tests offered other advantages.

The humor landed, too. Its trailer involved a team adding agents, shipping faster, alarming finance with the token bill, and getting downgraded to a cheap model that could solve only easy bugs. The final boss was the Monorepo. I played it and actually laughed. That creative specificity was more interesting to me than another generic shooter demo.

The ChatPRD migration is promising—and unfinished

The serious engineering test involved the product intelligence system I have been building at ChatPRD. It ingests, organizes, and summarizes information and builds an auto wiki. After roughly six months of iteration, the codebase was messy.

I asked Fable 5.2 to make the pipeline more efficient and easier to maintain, and to apply its product thinking. This was a broad architectural assignment, not an isolated bug fix.

The organization it proposed made sense to me. It aligned with work I already had in mind for the roadmap. It also behaved well during execution: it worked autonomously for stretches and stopped at appropriate moments, including when it needed a PR.

That interaction pattern matters. A model can be fast per turn and still slow you down by asking unnecessary questions or requiring constant supervision. Here, I felt it alerted me when it needed something without continually interrupting.

But I was only about halfway through the migration when I recorded. I cannot call this a completed, verified re-architecture. There were no finished performance measurements in this demonstration. The evidence supports a narrower conclusion: useful architectural organization and a good working experience on a genuinely messy project, with the final outcome still pending.

If you adapt this approach, keep the review boundary. Let the model investigate and implement, but evaluate the proposed structure against your product direction and inspect changes before accepting them. In this case, my own knowledge of the roadmap was part of judging whether its plan was sensible.

Good brand compliance does not mean good taste

Left alone to design a browser homepage intended to help me slow down, Fable produced something I strongly disliked. A ghostly storybook project had the same problem: functional enough to examine, visually unappealing.

An AI assistant generates visual concepts for a 'calming browser homepage,' showcasing abstract designs depicting clock times, as part of a design iteration process.

This is why the successful marketing video does not contradict my criticism of its design ability. With a strong brand or style guide, Fable could follow the direction tastefully. Without that constraint, I did not like its choices.

I also repeatedly reached for OpenAI’s ImageGen 2.5 when I needed generated imagery. The lack of an image-generation model showed up as a limitation in these creative projects.

My likely division of labor is therefore selective: use Fable for complex implementation, animation, and architectural work; use Opus 5.5 for some front-end design work; supply a strong visual reference rather than asking Fable to invent the aesthetic from nothing. That is a routing preference based on these tests, not a universal ranking.

The verdict: copy the bounded autonomy, keep the judgment

Anthropic positions Fable 5.2 for complexity, difficult engineering work, and long-running tasks, while Opus 5.5 remains suited to most daily coding and knowledge work. In the episode, I also discuss Mythos 5.2 as the same underlying model offered for cybersecurity and life sciences purposes. My hands-on tests did not encounter the model’s guardrails, which says more about my tasks than about the absence of restrictions.

The broader cross-model How I AI benchmark comparison was still to come. This episode is a first look, not the final benchmark verdict.

What is worth copying now is the combination of concrete inputs and room for initiative: a tweet plus a brand book, photos plus an assembly objective, an existing codebase plus a clear maintenance goal. Fable was particularly compelling for builders who can recognize a useful result and want the model to do substantial work between check-ins.

What still needs you: visual taste, physical verification, code review, and honesty about what is finished. I would happily use Fable 5.2 to animate our characters or tackle a difficult pipeline. I would not hand it an empty browser canvas and assume it knows what beautiful looks like.

Build your next product with ChatPRD

Turn an idea into a PRD, user stories, and a plan.

Try ChatPRD free

Start shipping better products.

Join 250,000+ product managers who use ChatPRD to write better docs, align teams faster, and build products users love.

Free to start · 14-day Pro trial · SOC 2 Type II