Ask an AI to Draw a Pelican Riding a Bicycle: The Tiny Prompt That Exposes Spatial Reasoning

Published: 2026-09-13 · 阅读量 --

AI Agent AI LLM SVG Automation Engineering Practice Troubleshooting Windows 11 Ubuntu 26.04 macOS 26

TL;DR

“Generate an SVG of a pelican riding a bicycle” is not just a cute drawing prompt. It is a tiny, surprisingly sharp AI exam. The model has to recognize a pelican, recognize a bicycle, understand the spatial relationship in “riding”, and translate all of that into SVG code a browser can render. Add “make the wheels turn, make the feet pedal, and make the body bob slightly” and the task becomes a test of modeling, programming, animation timing, and self-inspection.

This post explains where the informal benchmark came from, what real public model outputs get wrong, and how to run a completely offline, zero-dependency grader on Windows 11, Ubuntu 26.04, or macOS 26. The same workflow can be run by a human or configured by a local Agent. The punchline is simple: a silly pelican can reveal a model’s weaknesses more quickly than many polished “summarize this article” prompts.

Original cover: Pelican on a Bicycle · AI IQ Test

Figure 1: Original artwork. The task looks like drawing a bird and a bicycle, but it actually tests concept composition, 2D geometry, code generation, and self-checking.

1. Why a pelican on a bicycle?

The test was introduced by developer Simon Willison in a public experiment in October 2024. He set himself a very concrete informal benchmark: ask different models to generate an SVG of a pelican riding a bicycle. His reasons were both honest and methodologically useful: he likes pelicans, and he believed there were probably no existing “pelican on a bicycle” SVG files for models to simply reproduce from training data.

Here is the everyday analogy. Asking an AI to write “spring is beautiful” is like asking a student to write an essay with “some emotion”—templates go a long way. Asking it to draw a long-billed pelican riding a bicycle is more like asking a child to draw an elephant on a skateboard with four wheels aligned. The prompt is short, but memorized phrases are not enough.

Screenshot of Simon Willison’s pelican tag page

Figure 2: Real screenshot. Simon’s blog has grown a long-running archive of pelican outputs, turning the joke into a visual capability timeline.

The original prompt is exactly one sentence:

Generate an SVG of a pelican riding a bicycle

It does not specify the pose, wheel coordinates, beak angle, or whether the pelican should have wings. The model must supply those details from its learned concepts. It is like giving a child a box containing a toy bird and a toy bicycle and saying: “Put the bird on the bicycle.” Knowing both objects separately does not guarantee knowing how to assemble them.

Screenshot of the original benchmark post

Figure 3: Real screenshot. The source post records the origin of the informal benchmark and the first side-by-side model comparison.

2. What goes wrong: different models fail in different ways

I downloaded 22 early SVG outputs from Simon’s public repository, covering Claude, GPT, Gemini, Llama, and Amazon Nova families. A selection is shown in two “exam answer” galleries below.

Real model outputs: failure gallery

Figure 4: Real screenshot. GPT-3.5 Turbo turns the bicycle into a black rectangle; Gemini 1.5 Pro 001 has only one wheel; smaller models often flatten the bird and bicycle into unrelated colored blocks.

The recurring failures fall into seven groups:

Wrong wheel count: one wheel, or extra circles mistaken for wheels.
Wrong wheel sizes: a child-sized front wheel and a truck-sized rear wheel.
Floating wheels: both circles exist, but their bottoms are not on the same ground level.
No riding relationship: the pelican stands beside the bicycle, or its body is merged with the wheel.
Beak fused to the handlebar: the model knows a pelican needs a beak and a bicycle needs handlebars, but cannot maintain a sensible gap.
Feet miss the pedals: legs are drawn, yet the feet stop in midair—or both legs come from the same side.
Invalid SVG: missing xmlns, an invalid viewBox, or malformed markup causes the browser to refuse rendering.

Real model outputs: progress gallery

Figure 5: Real screenshot. Claude 3.5 Sonnet, Gemini experimental 1206, and o1-preview can express “a bird on a bicycle” much more reliably, but visual plausibility is still not the same as perfect mechanics.

The early outputs are revealing. GPT-3.5 produces very short code but reduces the bicycle to almost a symbol. Claude 3.5 Sonnet draws a recognizable diamond frame, two equal wheels, and a long-billed bird. Gemini experimental 1206 adds sky, grass, and spokes. Code length, visual polish, and geometric correctness do not always move together—which is exactly why this makes a useful engineering smoke test.

3. One picture hides four different exams

3.1 Semantic composition: pelican + bicycle

Ask “What is a pelican?” and most models can answer. Ask “What parts does a bicycle have?” and they can list them. But “a pelican riding a bicycle” requires putting the two concepts into one coherent spatial sketch. The pelican needs a long beak, pouch, wings, and legs. The bicycle needs two wheels, a frame, seat, handlebars, and pedals. Most importantly: the bird must sit above the seat, its feet should reach the pedals, and the wheels should meet the ground.

This is compositional generalization. A child can have a toy bird and a toy car in the same box without knowing how to place the bird so that it is actually riding the car.

3.2 Geometry: SVG is a programmable paintbrush

SVG is not a finished photograph. It is a list of geometric instructions. circle draws a circle, ellipse draws an ellipse, line draws a line, and path draws a curve. The model must choose coordinates: where are the wheel centers? where is the bird’s center? how far should the beak reach?

The browser is a strict referee. If you say “put the wheel here,” it does not guess what you meant. A 20-pixel error remains a 20-pixel error. A human can look at a sketch and say “close enough”; SVG faithfully renders the mistake.

3.3 Programming: static art and animation are different difficulty levels

A static image only needs the geometry to be placed correctly. An animation adds time. The wheel must rotate around its hub, the crank must rotate around the bottom bracket, the feet must follow the pedals, and the bird may bob slightly—but it should not launch like a rocket.

Original SVG: static pelican on a bicycle

Figure 6: Original artwork. The static version makes the important relationships explicit: two equal wheels, a ground line, a diamond frame, a bird body, and an orange beak.

Animation is like cycling itself: beautiful wheel motion is not enough if the feet never touch the pedals. A slightly wrong rotation center becomes obvious as soon as the wheel starts wobbling. The following image is a pure SVG animation using no JavaScript and no external assets.

Original SVG animation: synchronized wheels, crank, and body

Figure 7: Original artwork. The animated version uses SVG’s built-in animate and animateTransform, so it plays directly in a browser.

3.4 Self-inspection: did the model ever see its own answer?

When a human draws, they look back at the page: if the wheel is crooked, they erase it; if the beak touches the handlebar, they move it. Many language models behave like blindfolded painters. They generate a large SVG string but never render it and never inspect the final result.

Original analogy: the blindfolded drawing model

Figure 8: Original artwork. Generating code without rendering and looking back is like drawing blindfolded; a human at least keeps checking the paper.

That is why asking an AI to make a 2D animation is more revealing than asking it for code alone. Motion amplifies hidden errors: a barely visible crank offset turns into a flying pedal, and an off-center wheel becomes a drunken wobble.

4. Root causes: why “can draw” and “draws correctly” are different

First, a language model predicts the next token. It can be very good at predicting that bicycles usually have two wheels and pelicans usually have long beaks without maintaining a stable 2D coordinate map. It is like someone who has memorized architectural vocabulary but has never built a vertical brick wall.

Second, code and images in training data are not always tightly paired. A model may have seen many SVG fragments but very few examples of the exact composition “pelican riding a bicycle”. It recombines familiar local pieces into an unfamiliar whole.

Third, the generation pipeline often lacks a visual loop. One component writes SVG, another renders it, and a vision model could inspect it—but unless those steps are wired together, the error remains at the stage where the code merely looks plausible.

Fourth, informal benchmarks can themselves become overtrained. Dylan Castillo’s “pelicanmaxxing” investigation discusses whether AI labs could be training specifically on this prompt. That is an important warning: the pelican test is a quick health check, not a complete IQ certificate. If every model memorizes the same answer, we are measuring memory rather than reasoning.

Screenshot of Simon’s pelican talk post

Figure 9: Real screenshot. Simon also uses the pelican images in talks to illustrate changing model capabilities. It is better understood as a visual timeline than as a rigorous academic leaderboard.

5. The practical fix: turn one-shot generation into a render–inspect–repair loop

The most effective improvement is not an endlessly longer prompt. It is giving the Agent a way to see what it made. A useful loop is:

Ask the model for a complete, standalone SVG file.
Open the SVG in a browser or local renderer.
Capture or inspect the rendered result.
Check a short list: two wheels? equal wheels? same ground level? bird on the bike? orange beak? working animation?
Send the problems and screenshot back to the model; ask it to change only the broken parts.
Stop after 2–4 loops and keep the failed sample instead of hiding it.

Original diagram: Agent visual self-check loop

Figure 10: Original artwork. Add a renderer and a checklist and the blindfolded painter now has a proctor.

5.1 Manual one-command execution

The companion package includes pelican_exam.py, a local grader that uses only Python’s standard library. It never uploads the SVG and makes no network requests. The score is not an aesthetic judgment; it is a heuristic geometry check:

SVG root and xmlns: 10 points;
viewBox: 10 points;
exactly two wheel-sized circles: 15 points;
equal wheel radii: 10 points;
equal wheel ground level: 10 points;
a bird body above the wheels: 10 points;
orange beak color: 10 points;
line or path skeleton: 10 points;
composition covers at least 20% of the viewBox: 15 points;
animation elements are reported as a bonus signal rather than mixed into the static score.

Windows 11

# 1. Generate a template on first run
.\\pelican-exam-windows11.ps1

# 2. Paste the AI SVG into my-answer.svg, then grade it
.\\pelican-exam-windows11.ps1 .\\my-answer.svg

This version uses PowerShell’s built-in XML parser and stays offline. If local script execution is blocked, allow it only for the current process:

Set-ExecutionPolicy -Scope Process Bypass

Ubuntu 26.04

chmod +x pelican-exam-ubuntu2604.sh
./pelican-exam-ubuntu2604.sh
./pelican-exam-ubuntu2604.sh my-answer.svg

macOS 26

chmod +x pelican-exam-macos26.zsh
./pelican-exam-macos26.zsh
./pelican-exam-macos26.zsh my-answer.svg

The Ubuntu and macOS versions use only the system Python 3 standard library. On a minimal installation, the script will tell you if python3 is missing. No Pillow, Cairo, browser extension, or online service is required.

Real terminal screenshot of the grader

Figure 11: Real screenshot. The local grader scores GPT-3.5 Turbo and Claude 3.5 Sonnet output item by item and explains every failed check.

5.2 Agent auto-configuration

Give this task brief to a local Agent. It does not need an external service:

Create a pelican-exam directory in the current folder.
1. Write pelican_exam.py, pelican-exam-windows11.ps1, pelican-exam-ubuntu2604.sh,
   and pelican-exam-macos26.zsh.
2. Use only operating-system built-ins. Do not pip/npm install dependencies and do not upload files.
3. Run python3 pelican_exam.py --demo and confirm the broken sample is about 10 points and the good sample about 100.
4. Batch-grade all SVG files in the directory and print every pass/fail reason and total score.
5. If an SVG is invalid XML, report the error and never overwrite the original.
6. Produce a JSON or Markdown report with filename, score, and failure reasons.

The human workflow is a teacher grading papers one at a time. The Agent workflow is an assistant handling the exam setup, collection, and statistics. The rubric is identical.

6. A reusable prompt: make the acceptance criteria explicit

If you want a stronger one-shot attempt, try the following prompt. It may reduce errors, but it cannot replace rendering and inspection:

Create one self-contained animated SVG, 800x500 viewBox, with no external assets.
Draw a recognizable brown-and-white pelican riding a red bicycle on a green ground line.
The bicycle must have exactly two equal-size wheels whose bottoms share the same y coordinate,
a visible diamond frame, a seat, handlebar, crank and two pedals.
The pelican must sit above the seat, have two orange legs reaching the pedals,
a long orange beak pointing toward (but not touching) the handlebar, one visible eye and wings.
Animate both wheels around their own hubs, animate the crank and pedals around the bottom bracket,
and add a subtle body bob. Use SVG animate/animateTransform only; do not use external JavaScript.
After generating, mentally verify: two wheels, equal radii, same ground level, bird on bike,
beak separated from handlebar, both feet connected to pedals, and valid XML.
Return only the SVG.

This uses a “rubric first” strategy: the student receives the checklist before the exam. It improves instruction following, but it does not prove the model saw the final rendered image. Keep the visual loop.

7. Q&A: Is this really an AI IQ test?

Q1: Does a prettier drawing mean a smarter model?

No. It is like one small gauge on a car dashboard. It can reveal a problem in certain capabilities, but it cannot summarize the whole vehicle. One model may write excellent code but compose poorly; another may make a beautiful scene but fail to explain its coordinate system.

Q2: Why not use standard math or coding questions?

Use them too. Standard tests are important, but many are heavily represented in training data. The pelican task combines language, geometry, code, vision, and animation in an open-ended output. It complements formal evaluations; it does not replace them.

Q3: Why SVG instead of PNG?

SVG is text code, so it is easy to save, compare, audit, and patch. You can inspect element counts, circle centers, colors, and animation tags. A PNG tells you what the final pixels look like, but not how the model constructed them.

Q4: Can a model simply memorize the prompt?

Yes. Do not test only one pelican. Rotate in “a duck driving a tricycle”, “a giraffe riding a unicycle”, or “a penguin pushing a shopping cart”. Randomize colors, poses, and animation requirements. A high score on one prompt only proves that the model passed that prompt.

Q5: Can the offline grader make false judgments?

Absolutely. It checks SVG structure and simple geometry; it cannot truly understand whether a white ellipse is a pelican. Treat it as a mechanical first pass: filter obvious errors, then use a human or vision model for semantic and aesthetic review.

8. Conclusion: the real exam is noticing that you drew it wrong

The pelican-on-a-bicycle test is funny because it compresses a big AI question into a scene anyone can inspect. You do not need to read dozens of papers first. Just look: are there two wheels? Is the bird sitting on the bike? Can its feet reach the pedals? Do the wheels spin without the whole bicycle wobbling apart?

The public outputs show real progress: from rectangular frames and single-wheel bicycles to scenes that express bird, bicycle, ground, and motion together. But the deeper lesson is not which vendor wins. It is an engineering lesson: generation must be connected to rendering, observation, verification, and repair.

The next time you evaluate a new model, do not begin by asking “How smart are you?” Give it a pelican, a bicycle, and a browser. A capable model does not merely produce code that looks like an answer. It puts the wheels on the ground, notices what is wrong, and gets the pelican riding.