Why LLMs Are Good at Generating Scenes but Struggle with Human Figures

The Symptom: Scenes Work, People Break

Using natural language to drive an LLM to produce runnable graphics code has become a common way to prototype scenes quickly. The typical outcome: streets, buildings, hills, trees, and water are instantly recognizable, while human figures—once they enter the frame—fail simultaneously on proportion, joints, facial features, and orientation. This is not an occasional prompt mistake but a systematic difference rooted in task type.

A boundary needs to be drawn first. This article discusses “language models generating geometry and drawing instructions from text,” not dedicated image-generation models producing pixels directly. The former’s intermediate output is parametric primitives, paths, transforms, and material descriptions; the latter fits textures in pixel space. Both expose weaknesses on human figures, but the mechanisms differ. This article focuses on the former: the model must translate “a person standing beside steps” into a structure that is executable, renderable, and still looks human after projection.

Why Architecture and Nature Are Easy to “Write”

Buildings and most natural elements are, in code, built from a small set of stacked rules.

A building’s dominant structure consists of boxes, extrusions, repeated windows, aligned axes, and a few material zones. Language like “three-story pitched roof, symmetric on both sides, ground-floor porch” maps directly onto a set of dimensions, repeat counts, and symmetry transforms. Errors are often absorbed into style: slightly wider windows or one less cornice detail, and viewers still recognize a house. Repetition also provides statistical self-consistency—when the same parameters are instantiated many times, local errors are covered by the overall rhythm.

Natural elements benefit from procedural priors too. Terrain can be approximated with height fields and fractal noise; canopies with instanced clumps or simplified leaf clusters; water with a plane plus perturbed normals; sky with gradients and a bit of volumetric light. The “correctness” of these objects means statistically resembling a category of scenery, not matching a specific anatomical measurement. As long as the model calls familiar noise, instancing, and lighting patterns, the result falls within humans’ loose mental template of a landscape.

Scene-building therefore aligns closely with LLM strengths: composing known patterns, filling plausible numeric ranges, and maintaining global symmetry and repetition. It demands “the average look of a category of objects,” not “the unique topology of one specific living body in a particular pose.”

Where Figures Get Hard: Constraint Density Far Exceeds Primitive Expressiveness

When figures fail, it is usually not missing skin textures—the geometric constraints are already violated before projection. The difficulty breaks into several layers.

Layer one: proportion and topology. Adult head-to-body ratio, shoulder width, pelvis width, and limb segment lengths all sit within narrow ranges. If the code assembles independent boxes and spheres, every part’s size, anchor point, and parent-child hierarchy must be simultaneously correct. Miss one parent-child link and the arm grows from the center of the chest; shift an anchor a few units and the elbow folds outside the body. A building can lose a window; a person cannot lose a properly connected upper arm.

Layer two: pose and joint limits. Standing, walking, and sitting all imply joint angle ranges and ground contact. Language models are good at describing “he leans slightly, one hand in his pocket,” but poor at maintaining inverse kinematics in a single generation: the hand’s target position, the elbow’s bending plane, and the feet’s contact with the ground must be solved jointly. Without an explicit skeleton and constraint solver, the model writes hardcoded rotation angles from memory; change the camera or height slightly, and limbs clip through the body or float in the air.

Layer three: the face as a high-dimensional detail zone. Eye spacing, the nose-to-mouth relationship, ear height—a deviation of a few pixels turns “a person” into “a symbol approximating a face.” Vector paths or low-poly meshes have almost no tolerance for this, and the model can rarely output hundreds of control points stably in text while keeping both eyes symmetric under perspective.

Layer four: identity and temporal consistency. If a scene has multiple people, or the same person appears across shots, clothing silhouette, hairstyle, and body shape must be reusable. Independently generated meshes are each on their own, with poor reusability—so “no two people look like the same species.”

These are hard constraints: violating any single one breaks overall recognition. A building violating one soft constraint usually still reads as a building. That is the first-principles reason “scenes are easy, people are hard”—the error-tolerance structures are completely different.

Training and Representation: Language Statistics Can’t Cover Biological Geometry

LLMs have seen abundant text on “how to build scenes with code”: layouts, lighting, instancing, noise terrain, simple character placeholders. Production-grade character assets, by contrast, usually come from external modeling pipelines; codebases more often load finished meshes than write skinning, rigging, and facial expressions from scratch. The model’s conditional distribution therefore leans toward “box people, capsules, symbolic faces” rather than usable human bodies.

The representation layer is equally unfriendly. A renderable human requires, at minimum: a surface (or voxels), a skeleton, skinning weights, blend shapes where needed, and bindings to animation curves. What a single natural-language “wish” can reliably fill is usually only a rough proxy of the surface. Weights and joint limits are dense numerical data—unsuitable for prose description and easily omitted during generation. The model falls back to the primitive assembly it is more confident about, and the assembled result is structurally not a person.

Additionally, text tokens encode spatial relationships only indirectly. “The left eye is slightly higher than the right” is short in a sentence, but in a mesh it is a coordinated edit of many vertices. The model never sees the projected result during generation, so it cannot calibrate the word “slightly” to screen space. In scenery, this calibration error is absorbed by repeated textures; in figures, it concentrates on the face and hands—small regions—where it is amplified into obvious mistakes.

Perception: Human Eyes Are Unforgiving Toward Humans

Viewers hold category-level internal models of buildings and trees: a roof, some openings, a canopy blob—recognition is done. For the human body, checking is part-level or even feature-level: head-to-body ratio, finger count, elbow orientation, gaze direction are each inspected individually. This is the high-sensitivity band near the uncanny valley—photorealism is not required, but “biological plausibility” is.

The same magnitude of geometric error reads as style on a building and deformity on a body. Evaluation metrics that only check “does the code run, does the scene contain objects” systematically overestimate scene generation and underestimate figure generation. In practice, figures should have their own acceptance criteria: proportion, ground contact, no joint hyperextension, facial feature relative positions, and left-right symmetry under the actual camera.

No Feedback Loop Amplifies the Weakness

Generating code from one round of natural language without ever looking at the rendered image means letting the model guess parameters under open-loop conditions. A building’s parameter space is flat—guessing within a plausible range suffices. A human body’s parameter space is narrow and coupled—open-loop guesses rarely land.

Common failure modes include: treating the character as a scene prop and substituting a stretched box; piling up spheres to “look human” with no unified skeleton; drawing the face as two arcs for eyes that misalign the moment the camera moves; animating by rotating the entire mesh while limbs never swing with the gait. None of these are renderer limitations—they are symptoms of the task being wrongly decomposed into “write a few more shapes.”

Practical Fixes: Turn Figure Generation into Constraint Solving, Not Another Wish

Do not expect a more elaborate description to reliably produce a usable character. Change the task decomposition instead.

1. Separate figures from scenery. Keep generating scenes with procedural primitives, instancing, and noise. Describe characters separately: height, segment-length ratios, resting pose, contact points. Combine the two in the scene graph only through position and orientation. This way, the scene’s high success rate is not dragged down by figure failures, and the figure can be iterated on independently.

2. Replace free-form modeling with parametric templates. Predefine a body segmentation—head, neck, torso, upper arm, forearm, hand, thigh, shin, foot—where each segment has only a length, a radius, and joint angles. The model may only modify parameters, never add or remove topology. A template shrinks the search space from “arbitrary mesh” to “a dozen bounded numbers.”

A schematic constraint spec might look like this (conceptual, not tied to any specific graphics API):

human:
  height: 1.75
  segments: head, neck, torso, upperArm, forearm, thigh, shank
  joints:
    elbow: [0, 145]      # degrees, flexion only
    knee:  [0, 140]
  contacts:
    feet: ground
  face:
    eyeDistance: 0.32 * headWidth
    symmetry: mirrorX

Model output should be rejected or clamped by a validator: angles out of range, feet off the ground, eye spacing deviating from the head-width ratio—none of these should go straight to rendering. Validation beats “generate another version” because it targets hard constraints, not writing style.

3. Be honest about facial simplification. If the current pipeline only has primitives and simple paths, use a readable stylized face (clear positional relationships between eyes, nose, and mouth) and declare it a symbolic representation. Do not fake realism with masses of unconstrained curves. A realistic face needs denser control points or an external mesh; single-shot text generation is not reliable for this.

4. Add a visual review loop. Render three previews—front view, side view, and the current story camera—and let the model modify parameters based only on “which constraint failed”: e.g., “elbow reversed, left foot floating 0.2 above ground, eye spacing too wide.” Feedback must be measurable deviation, not “looks weird.” Measurements come from skeleton lengths and projected positions, not the model’s own subjective description.

5. Drive animation with skeleton curves, not whole-mesh rotation. Walking should at least include pelvic displacement, legs in opposite phase, arms counter-swinging, and near-zero foot velocity during stance. These can be expressed with a few sinusoidal phase functions—still within a text model’s capability—but a skeleton must exist first.

6. Reuse and variation. Save one set of segmentation parameters as a character spec; change outfits by swapping attachments, never bone lengths. Generate multi-person scenes from a spec table instead of describing a “new person” from scratch each time.

Is the Problem the Model or the Task Design?

If buildings, terrain, and vegetation are stable but every character collapses, suspect the task design first: did you ask the model to invent topology in a single output? If adding a segmentation template and joint limits fixes standing immediately but walking is still broken, what’s missing is temporal constraints, not “understanding of humans.” If the front view is fine but the face falls apart at an angle, the face is not bound to the head’s coordinate system, or symmetry is not being computed under perspective. Classifying failures into proportion, joints, contact, face, and animation converges faster than endlessly rewriting adjectives.

Also accept capability limits. Without skinning and facial rigging—only primitive assembly—the goal should be “structurally correct stylized characters,” not anatomical realism. Writing acceptance criteria into prompts and automated checks narrows the model’s freedom but noticeably improves the usable rate. This is the exact opposite of scenery, where encouraging the model to play freely with noise and decoration is the right strategy.

Summary

LLMs excel at architecture and nature because these objects have clear rules, heavy repetition, high perceptual tolerance, and align with the common practice of “writing scenes with parameters and primitives.” Figures are hard because proportion, joints, contact, and facial features form a dense set of hard constraints that open-loop text rarely gets right in one pass—while human eyes almost never miss a local error. The solution is not longer appearance adjectives, but separating figures from scenery, parametric bodies, range validation, per-camera measurement, and skeleton-level animation. Turn figure generation from inspiration-driven creation into constraint satisfaction, and the people in your scenes will finally match the maturity of the scenery around them.