Testing Claude for 3D Animation: A Single Prompt Generates a Low-Poly Galloping Horse

How Far Can Claude Go with 3D?

Using large language models as a generation engine for 3D content is becoming an increasingly popular way for creators to probe the boundaries of AI capabilities. A Reddit user shared their experiment: using different versions of Claude with a single natural-language prompt, they attempted to generate a low-poly galloping horse animation that runs as a seamless loop in the browser. According to the post, Claude Max took a full hour to complete the task — but the result was genuinely impressive.

What makes this case worth examining isn't the visual spectacle of the final output, but what it reveals about the real capabilities of today's code-generation models in the niche domain of "procedural 3D modeling" — from geometry construction and skeletal animation to final file packaging, all inferred in a single pass by the model.

The Technical Challenges Hidden in the Prompt

Here's the prompt used in the original post:

Create a low-poly 3D horse running in a seamless loop using Three.js. Build it procedurally from primitive geometry, animate the legs, body, head, and tail, and return a single self-contained HTML file.

This single sentence actually imposes multiple layers of technical requirements on the model:

Procedural Modeling

"Procedurally from primitive geometry" means the model cannot use any pre-made 3D assets. Instead, it must manually assemble a horse-shaped figure in code using basic shapes like boxes, cylinders, and spheres. This tests the model's understanding of spatial structure and coordinate systems — the position, proportions, and orientation of every leg must be defined with numerical precision.

Three.js is a JavaScript 3D graphics library built on WebGL that runs in the browser without any local installation. It provides three core objects — Scene, Camera, and Renderer — along with built-in primitive geometries like BoxGeometry, CylinderGeometry, and SphereGeometry. Procedural modeling refers to defining three-dimensional shapes entirely through code rather than through art software like Blender or Maya — each geometry's position is defined by xyz coordinates, rotation by Euler angles or quaternions, and hierarchy by parent-child relationships via Object3D.add(). For a language model, the challenge is maintaining a mental model of 3D space: how far in front of or behind the torso should each leg be? At what angle should the neck tilt to match a horse's proportions? All of this must be expressed as pure numerical values in code, with no real-time preview to catch mistakes.

Animation and Loop Logic

"Seamless loop" requires the limb movement cycle to connect end-to-end without any visible jump between frames. To make the gallop look natural, the model needs to understand the rhythm of a horse's gait and use sine functions or keyframes to drive the legs, head, neck, and tail with staggered phase offsets. This goes beyond simple code completion — it involves modeling real physical movement patterns.

The sine function (Math.sin) is the most common periodic driver in procedural animation: multiplying a timestamp by a frequency coefficient and passing it into sin produces a smooth value oscillating between -1 and 1, which can then be mapped to joint rotation angles to simulate limb movement. A horse's gallop is biomechanically asymmetric — each leg strikes the ground in a specific phase sequence — which is entirely different from the diagonal synchrony of a trot. For the animation to look natural, the front and rear legs typically need roughly half a cycle (π) of phase offset, while legs on the same side also need to be staggered. The challenge of a "seamless loop" is that the last frame must exactly match the state of the first frame; otherwise, a visible jump will appear at the loop point. Using pure trigonometric functions naturally satisfies this requirement, since a sine wave is inherently infinite and periodic.

Self-Contained Delivery

"Single self-contained HTML file" means all logic, the Three.js import, and the render loop must be packaged into one file that opens directly in a browser. This sets a hard standard for the completeness and executability of the output — any missing dependency will result in a blank screen.

A "self-contained HTML file" means all resources the page needs — including the Three.js library itself — must be embedded within a single file, with no reliance on external CDNs or relative path references. There are typically two approaches: referencing an online CDN via <script src="https://cdn.jsdelivr.net/..."> (requires an internet connection when opening the page), or inlining the entire Three.js source as a <script> tag directly in the file (fully offline-capable, but the file size can reach hundreds of KB). Which approach the model chooses directly affects the file's portability. Additionally, the self-contained requirement means every piece of initialization logic — the render loop, camera controls, lighting setup — must be complete. Any missing variable declaration or absent animate() call will produce a blank page, and error messages can only be seen through the browser's developer console. This is arguably the most demanding aspect of such tasks in terms of output completeness.

What Does an Hour of Processing Time Tell Us?

The post mentions that Claude Max took about an hour to produce the result. That "one hour" almost certainly includes multiple rounds of iteration, debugging, and version comparison — not the time for a single inference pass. It reflects a real constraint: getting a model to write correct complex procedural 3D code in one shot remains difficult, and typically requires human-AI collaboration with repeated corrections — fixing geometry clipping, wrong animation phases, unsuitable camera angles, and so on.

This also explains why the original post asked "which version do you think is best?" The creator clearly generated multiple candidate outputs and selected from among them. This "cast a wide net + manual curation" workflow is the typical pattern for AI-assisted creative generation today: the model rapidly produces multiple possibilities, while the human handles aesthetic judgment and quality control.

Practical Takeaways for Creators

For developers and designers who want to experiment with Claude or similar models for 3D work, this case offers a few actionable lessons:

• Three.js is an ideal testbed. It's web-based, requires no extra environment setup, and delivers immediate visual feedback — perfect for quickly evaluating model output quality.
• Pack your constraints into the prompt. The original prompt included "low-poly," "procedural," specific animated body parts, and the delivery format all in one sentence. Explicit constraints significantly improve the usability of the output.
• Expect multiple iterations. Don't count on the first generation being perfect. Think of the model as a collaborator for rapid prototyping and error testing, not a black box that produces finished work at the push of a button.

Final Thoughts

Generating a runnable 3D animation from a single sentence would have sounded like science fiction just a few years ago. Today it's an experiment that ordinary users can complete in their spare time. The process still requires patience and curation, but the model's performance on procedural modeling and animation logic genuinely demonstrates the trend of code-generation capabilities evolving from "writing functions" toward "building complete interactive works."

These seemingly lightweight community experiments are precisely the most vivid samples for observing the boundaries of AI's creative capabilities.

Note: This article is based on a single experiment shared by a Reddit user. Actual results will vary depending on the model version, prompt wording, and number of iterations. Readers are encouraged to reproduce and verify the results themselves.