Anthropic’s Claude Fable 5.2 is demonstrating an unusual approach to digital art: instead of generating images through a conventional AI image-generation model, it creates paintings by writing code that simulates individual brushstrokes on a virtual canvas. The model can control brush movement, paint thickness, colour, texture and layering, gradually building detailed artwork through thousands or even hundreds of thousands of individual strokes.

The technique has attracted attention after Anthropic engineer Jake Eaton shared demonstrations of the model creating complex paintings, including a photorealistic shopping cart in a parking garage. The experiment used approximately 700,000 simulated brushstrokes. Another demonstration by Anthropic engineer Michael Graczyk showed the model painting a bird at sunrise using just 111 carefully planned stroke sequences. These examples highlight how advanced reasoning and coding capabilities can be used for creative work beyond conventional image generation.

Claude Fable 5.2 Uses Code Instead of an Image Generation Model

Most popular AI image generators use diffusion-based techniques to produce images. These systems typically begin with noise and gradually transform it into a recognisable picture through a series of computational steps.

Claude Fable 5.2 follows a different approach.

Rather than directly producing an image through an image-generation model, it writes Python code that controls a simulated painting environment. The code instructs a virtual brush where to move, which colour to use, how much pressure to apply and how the paint should interact with the canvas.

The process resembles traditional painting, where an artist gradually builds an image through individual strokes.

According to Eaton, the Python programs behind some of the experiments contain approximately 1,000 to 2,000 lines of code. The model develops instructions for a simulated painting engine that accounts for brush characteristics and paint application.

This approach allows Claude to construct artwork through a sequence of deliberate actions rather than generating the complete image in a single operation.

One Painting Used Approximately 700,000 Brushstrokes

One of the most striking demonstrations involved a shopping cart in a parking garage.

Eaton asked Claude Fable 5.2 to create a painting that would be as difficult to distinguish from a photograph as possible.

The model produced the scene using approximately 700,000 simulated brushstrokes.

<text color=”secondary” size=”xs”>Demonstration shared by Anthropic engineer Jake Eaton.</text>

<AsyncImageGroup query={[“Claude Fable 5.2 700000 brushstrokes photorealistic shopping cart parking garage Jake Eaton”,”Claude Fable 5.2 AI painting brushstroke artwork Jake Eaton”]} aspectRatio=”5:4″ layout=”bento”/>

The result demonstrated how the model could use thousands of small visual decisions to reproduce complex details, including lighting, reflections, objects and environmental textures.

Unlike a conventional image-generation workflow, the model had to construct the scene through its simulated painting process.

Eaton said the system did not use an external image model or pre-rendered and traced source images for the demonstration.

The experiment is significant because it shows how a language model can use programming and iterative visual reasoning to create an image without relying on a dedicated image-generation architecture.

Claude Can Correct Its Own Painting Mistakes

Another interesting aspect of the technique is how the model responds to errors.

In a separate experiment, Anthropic engineer Michael Graczyk asked Fable 5.2 to paint a bird against a sunrise background.

The model was restricted to producing individual brushstrokes through code. It could not simply undo an earlier stroke after placing it on the canvas.

The demonstration used 111 coordinate sequences and produced a 21-second video showing the painting taking shape.

<AsyncImageGroup query={[“Claude Fable 5.2 bird sunrise painting 111 brush strokes Michael Graczyk”,”Claude Fable 5.2 painting process bird virtual canvas brushstrokes”]} aspectRatio=”5:4″/>

The model began by selecting colours, brush widths and movement coordinates. It also introduced slight variations in brush movement to make the strokes resemble the natural movement of a human hand.

After examining the developing painting, Claude identified areas that needed improvement.

For example, when the bird’s back appeared too thin, the model placed additional strokes over the existing area to create a fuller appearance.

This process demonstrates an important capability: the model can inspect the results of its own actions, identify visual problems and make corrections through additional code.

The same approach was used in another painting of two people working together at dusk. When a lighting effect accidentally distorted objects on a table, the model added further strokes to restore those details.

The Model Creates Different Artistic Styles

Claude Fable 5.2 is not limited to reproducing a single painting technique.

Eaton has also experimented with asking the model to develop fictional artist personas with distinct backgrounds and consistent visual styles.

Instead of simply copying an existing artistic approach, the model can create different brush engines and painting methods based on the desired style.

These experiments involve adjusting the simulated brushes, colours, textures and ways of applying paint.

Eaton has shared several examples of the model exploring subjects such as light, human activity, landscapes and industrial environments.

Some experiments have also produced unusual conceptual artwork, including images in which the program’s own source code becomes part of the visual composition.

This suggests that code-driven painting can support more than photorealistic image reproduction. It can also be used to explore visual ideas and artistic concepts.

Claude Fable 5.2’s Painting Skills Could Extend to Robotics

The ability to plan individual movements and correct mistakes could have applications beyond digital artwork.

The same reasoning process is relevant to robotics, where machines must translate instructions into physical actions while responding to changes in their environment.

A robot arm, for example, needs to calculate movement, control pressure and position objects accurately. It must also respond when an action does not produce the intended result.

AI researcher Aris Zhu tested Fable 5.2 using physical robotic arms, comparing its performance with OpenAI’s GPT-6 Astra in a painting experiment involving Vincent van Gogh’s The Starry Night.

Anthropic reported that Fable 5.2 scored 64.9% on its internal RoboDojo Sim benchmark, compared with 29.8% for GPT-6 Astra.

However, the simulation results do not tell the entire story. Zhu’s real-world comparison showed that Astra was faster and demonstrated stronger performance in certain fine-motor tasks.

The experiment highlights an important distinction between planning actions in a simulated environment and executing them successfully through physical hardware.

Nevertheless, the painting demonstrations suggest that the reasoning capabilities used to create digital artwork could also help AI systems operate tools and machines.

Anthropic Positions Fable 5.2 for Complex Technical Work

Claude Fable 5.2 was introduced on November 9, 2026, as Anthropic’s advanced model for demanding technical and professional tasks.

The company positions it for software engineering, scientific research, financial analysis, complex problem-solving and long-running agent workflows.

Its ability to coordinate hundreds or even more than 1,000 subagents is another part of its technical capabilities.

Anthropic has also demonstrated the model designing electronic devices, developing complex software and working through difficult scientific problems.

The painting experiments provide another example of how these capabilities can be applied creatively.

However, there is an important technical distinction: Fable 5.2 does not natively generate image files in the same way as dedicated image-generation models. Its painting demonstrations rely on code and a simulated rendering environment to produce the visual result.

The Bigger Picture

Claude Fable 5.2’s painting experiments demonstrate that AI creativity does not necessarily have to depend on conventional image-generation models. A language model with strong reasoning and programming capabilities can produce visual artwork by controlling a sequence of individual actions, examining the results and correcting mistakes.

This approach also highlights the growing overlap between AI agents, coding systems and physical-world applications. The ability to plan thousands of small actions and adapt when something goes wrong is relevant to digital design, engineering and robotics.

However, code-driven painting is not automatically a replacement for dedicated image generators. The technique can be computationally demanding and may take considerably longer than producing an image through a conventional generation model.

Looking Ahead

Anthropic’s experiments suggest that future AI systems could become more capable creative collaborators by combining reasoning, coding and visual feedback. Instead of simply returning an image, models could construct artwork through transparent sequences of actions, revise individual details and develop customised techniques. The same capabilities could also support applications in simulation, product design and robotics.

For now, Claude Fable 5.2’s painting demonstrations remain experimental examples rather than evidence that conventional image-generation technology is becoming obsolete. Their importance lies in showing another way AI can create visual work. As language models become better at interacting with tools and simulated environments, the distinction between generating an output and building it step by step could become increasingly important.

Get the day’s top stories in your inbox

One concise email. No spam, unsubscribe anytime.