Why LLMs Can Generate Landscapes and Buildings but Struggle with Human Figures

When developers try to generate 3D scenes or vector graphics code entirely through natural language, they often notice an interesting pattern: large language models can quickly assemble atmospheric cities, houses, mountains, trees, and rivers, but as soon as they are asked to produce a person with natural structure and believable posture, the results tend to show distorted proportions, dislocated joints, stiff faces, or awkward movement.

This gap is not simply a matter of “models being bad at drawing people.” More precisely, it comes from a combination of geometric regularity, data representation, code structure, visual error tolerance, and generation feedback mechanisms. Especially in scenarios where a language model directly writes graphics code, the model is not performing a pure drawing task. It must translate semantic descriptions into executable geometry, coordinate relationships, material parameters, and draw order. Human figures happen to be the class of objects with the most complex constraints and the errors that are easiest to detect.

1. Why Buildings Are Better Suited to Code-Based Generation

1.1 Buildings Are Mainly Composed of Regular Geometric Primitives

Most buildings can be decomposed into a set of relatively standard geometric elements, for example:

• Walls can be represented as boxes or planes;
• Roofs can be represented as prisms, sloped surfaces, or curved surfaces;
• Doors and windows can be represented as rectangular regions;
• Columns can be represented as cylinders;
• Floors can be generated through repetition and arrays;
• City blocks can be constructed through grids, paths, and random offsets.

These elements have clear dimensions, positions, and rotation parameters, which makes them very suitable for code representation. Even if the model does not truly understand structural mechanics, it can still generate a visually plausible building as long as it organizes the code according to a hierarchy of “main mass—floors—doors and windows—roof—decoration.”

For example, a simplified building can be abstracted as:

building_mass = box(width, height, depth)
for each floor:
    compute current floor height
    for each facade:
        place windows at fixed spacing
at the top of the main mass:
    add roof structure

This generation process is highly composable. As long as the model correctly handles loops, spacing, and hierarchy, it can produce stable results. Even if window positions are slightly off, the human eye will usually interpret it as a stylistic variation rather than a serious error.

1.2 Buildings Allow Symmetry, Repetition, and Modularization

Language models are very good at generating code with repetitive patterns, and modern architectural visuals happen to contain many repetitive structures, such as floor arrays, window grids, colonnades, and wall partitions.

Let the building width be (W), the number of windows to place be (N), and the edge margin be (M). Then the spacing between the centers of adjacent windows can be written as:

[
S = \frac{W - 2M}{N - 1}
]

The position of the (i)-th window is:

[
x_i = -\frac{W}{2} + M + iS
]

These calculation rules are clear and locally independent, and they are easy for large models to organize correctly. Even if the generated code does not reach engineering precision, the final image may still maintain a sense of order.

1.3 Architectural Style Can Mask Local Errors

Building forms have a large degree of design freedom. A wall that is not perfectly symmetrical can be interpreted as modern design; windows of inconsistent size can be interpreted as facade variation; an unusual roof angle may be seen as artistic expression.

In other words, buildings have high visual error tolerance. As long as the overall silhouette, vertical relationships, and perspective are not obviously broken, the human eye is usually willing to accept them.

2. Why Natural Landscapes Are Also Relatively Easy to Generate

Natural landscapes differ from buildings in that they do not rely on strict regular geometry, but they have another advantage: randomness itself is part of what makes nature feel natural.

2.1 Natural Objects Have No Single Correct Form

How tall should a mountain be, in which direction should a tree grow, and how many edges should a rock have? These questions usually have no single answer.

When generating terrain, a common approach is to first create a base surface and then overlay multi-scale perturbations:

[
h(x,z) = h0(x,z) + \sum{k=1}^{K} a_k n_k(x,z)
]

Where:

• (h_0) represents the base terrain trend;
• (n_k) represents continuous perturbations at different scales;
• (a_k) controls the strength of each perturbation layer;
• (K) represents the number of stacked layers.

Even if local undulations do not match real geological evolution, as long as the overall result shows continuous, layered height variation, the human eye will usually identify it as mountains, hills, or rock.

2.2 Irregularity Can Hide Computational Errors

Natural objects inherently contain curvature, branching, damage, and random distribution. Slightly unusual branch angles, uneven rock surfaces, or irregular cloud boundaries are often not considered generation failures.

Therefore, algorithms such as random functions, noise perturbation, particle distribution, and recursive branching can produce relatively rich visual results with a small amount of code. Even if the large model generates only an approximate rule set, it can still produce an image that “looks like nature.”

2.3 Atmosphere Matters More Than Exact Structure

The look of a natural scene depends heavily on color, lighting, fog, depth layering, and composition. For example, the same simplified mountain model can form a good sense of space as long as it includes brightness variation across distances, a low-contrast background, and appropriate ambient light.

This means the model does not need to accurately reproduce every rock. It only needs to capture semantic layers such as “sky—distant mountains—foreground—vegetation—water surface” to produce a complete scene.

3. Why Human Modeling Is Much More Difficult

3.1 The Human Body Is a Strongly Constrained System

The human body is not an arbitrary combination of geometric primitives. The head, torso, pelvis, limbs, and joints have relatively stable proportions and connection relationships.

A simplified human skeleton must consider at least:

• The ratio of the head to the body;
• Shoulder width versus pelvis width;
• Length relationships among the upper arm, forearm, and hand;
• Length relationships among the thigh, lower leg, and foot;
• The bending direction of the elbow and knee;
• Continuity of the spine, neck, and head;
• Balance relationships between the left and right limbs in a pose.

A building can place walls first and then add windows, but a human figure cannot attach an arm as an independent cylinder next to the torso at will. As soon as the shoulder connection is offset, the upper arm direction is wrong, or the hand scale is abnormal, the figure immediately looks unnatural.

3.2 Humans Are Extremely Sensitive to Figure Errors

The human eye has long been exposed to its own body and those of others, giving people very strong recognition ability for faces and body structure. Observers may not be able to say which muscle or joint is wrong, but they can quickly sense that “this person looks off.”

For buildings, a window offset by a few units may just be a design variation; for a face, slight differences in eye height, inconsistent pupil direction, or an unbalanced mouth corner position can noticeably break the look.

The error tolerance for human figures is far lower than for buildings and natural landscapes. This perceptual difference makes the same degree of geometric error produce completely different subjective results.

3.3 The Human Surface Is Not Equivalent to Skeleton Assembly

Using spheres for the head, cylinders for the limbs, and boxes for the torso can generate a recognizable simplified figure, but it is hard to generate a natural human body. The reason is that the real human surface needs continuous transitions at the joints.

For example, the shoulder is not a simple intersection of an arm cylinder and the torso. It is a complex surface formed jointly by the clavicle, scapular region, deltoid, and chest and back structures. Similar problems exist at the hip, knee, and neck.

If only basic geometric primitives are assembled, it is easy to produce:

• Shoulders that look like mechanical hinges;
• Arms and torso penetrating each other;
• Breaks between the pelvis and thighs;
• Surface collapse after knee bending;
• Stiff connections between the neck and head.

Solving these problems usually requires more reasonable topology, skinning weights, and deformation rules, and these are difficult to derive correctly from a single natural language description.

4. The Face Is the Most Difficult Part of Figure Generation

4.1 Facial Features Are Highly Concentrated

The face occupies a small area, yet it contains a large number of key features such as eyes, eyebrows, nose, lips, ears, and jaw. Each feature not only has its own shape but also has strict relative position relationships.

In 2D vector drawing, if the model directly creates two eyes, a nose, and a mouth separately based on natural language, it may generate a face that is semantically complete but proportionally inconsistent. This is because “containing all facial features” does not equal “forming a natural face.”

A more reliable method is to first establish a facial coordinate system. For example, using head width (W) and height (H) as references, express feature positions as normalized parameters:

left_eye_center  = (0.35W, 0.42H)
right_eye_center = (0.65W, 0.42H)
nose_tip         = (0.50W, 0.60H)
mouth_center     = (0.50W, 0.75H)

These values are illustrative only; specific proportions should be adjusted according to viewpoint, style, and character design. The key is not a fixed set of parameters, but ensuring that all facial features share the same reference coordinate system and are not generated independently.

4.2 Faces Require Strong Symmetry with Subtle Variation

A perfectly symmetrical face may look mechanical, but obvious asymmetry can easily create a sense of abnormality. Therefore, faces usually need “overall symmetry with local micro-variation.”

If code generation emphasizes only symmetry, the result may look like a mask; if the random perturbation is too large, it will break the coordination among the eyes, eyebrows, and mouth corners. A reasonable approach is to limit randomness to a very small range and apply constraints to key points.

4.3 Gaze and Expression Carry Semantics

The two eyes must not only be in the correct positions but also point toward similar visual targets. The mouth corners, eyelids, and eyebrows also need to jointly express emotion.

If the eyebrows indicate anger, the mouth corners indicate a smile, but the eyelids are relaxed, the figure will produce a semantic conflict. Figure drawing is therefore not just a geometry problem but also a coordination problem among expression parameters.

5. Core Limitations of Language Models Generating Graphics Code

5.1 Textual Correctness Does Not Equal Visual Correctness

Large language models mainly output symbol sequences. They can generate programs that are syntactically valid and structurally reasonable, but they may not be able to directly observe every pixel after the program runs.

As a result, the model may correctly complete the following tasks:

• Create a scene;
• Add geometric objects;
• Set positions and colors;
• Build animation loops;
• Write interaction logic.

But the fact that this code can execute does not mean the figure proportions are natural. Syntactic correctness, program runnability, and visual correctness are three different levels.

5.2 Coordinate Errors Accumulate Layer by Layer

Human figures generally use a hierarchical structure: the pelvis drives the torso, the torso drives the shoulders, the shoulders drive the upper arms, and the upper arms drive the forearms. Each level of rotation can affect the position and orientation of the next level.

Suppose a child node’s position in the parent’s local coordinates is (p), the parent transform is (T_p), and the child’s own transform is (T_c). Then the final position depends on the transform composition:

[
p_{world} = T_p T_c p
]

If the model confuses local coordinates with world coordinates, common results include arms detached from shoulders, incorrect rotation centers, and reversed directions of the left and right limbs. Buildings also involve hierarchical transforms, but building components are usually static, so problems are easier to spot and fix; human poses change continuously, making errors more complex.

5.3 Single-Pass Generation Lacks a Visual Loop

When generating a complete figure through only one round of prompting, the model usually cannot perform the iterative process of “render—observe—locate errors—modify parameters.” Without visual feedback, it can only guess the final image based on textual rules.

A truly effective generation system should form a closed loop:

natural language requirement
    ↓
generate structured scene description
    ↓
generate graphics code
    ↓
execute and render
    ↓
extract screenshots or keypoints
    ↓
detect proportion, occlusion, and pose issues
    ↓
adjust parameters and regenerate

The most important step here is not to keep adding prompt words, but to give the model verifiable results, such as human keypoint positions, bounding boxes, joint angles, left-right symmetry error, and occlusion relationships.

6. How to Improve Figure Generation Quality

6.1 Do Not Ask for a Complete Figure in One Pass

A more reliable approach is to split the task into multiple stages:

1. First generate a standard standing skeleton;
2. Check head-to-body ratio and limb lengths;
3. Add basic volume blocks;
4. Check joint connections;
5. Then add facial features, hair, and clothing;
6. Finally handle motion, expression, lighting, and materials.

This method reduces the number of constraints in a single generation and makes it easier to locate problems. If the final figure has an abnormal arm, developers can determine whether the issue comes from the skeleton, the surface, or the pose, instead of facing an entire block of code that is hard to debug.

6.2 Use Parametric Human Templates

Do not let the model decide human proportions from scratch every time. You can define a set of parameters with clear meanings:

character parameters:
    total_height
    head_ratio
    shoulder_width
    pelvis_width
    upper_arm_length
    forearm_length
    thigh_length
    lower_leg_length
    hand_scale
    foot_scale

Then calculate joint positions from these parameters. The advantage of parameterization is that modifying a character does not require rewriting the entire geometric structure; only a few high-level variables need to be adjusted.

Basic validation rules can also be added:

if the difference between left and right upper arm lengths exceeds the allowed range:
    mark as abnormal
if the wrist distance from the shoulder exceeds the total arm length:
    mark as pose error
if the knee bending direction clearly conflicts with the foot direction:
    request pose recalculation

These rules cannot replace full human kinematics, but they can filter out many obvious errors.

6.3 Prioritize Silhouette, Then Details

Whether a figure looks natural depends first on the overall silhouette and center of gravity, not on eyelashes or clothing texture. The recommended priority order is:

• Layer 1: overall proportions of head, torso, and limbs;
• Layer 2: stance, center of gravity, and movement direction;
• Layer 3: joint connections and surface continuity;
• Layer 4: facial structure;
• Layer 5: clothing, hair, and material details.

If the figure’s silhouette is already unbalanced, adding more details will not save the overall look.

6.4 Generate Left and Right Structures by Mirroring

For a standard standing pose, you can first generate the structure on one side of the body and then obtain the other side through mirroring. This reduces issues such as inconsistent left and right arm lengths and abnormal shoulder heights.

However, once you enter the motion stage, you cannot always keep perfect mirroring. Natural poses usually involve contralateral movement, for example, when the left leg moves forward, the right arm moves forward. The correct strategy is to first use mirroring to ensure consistent basic structure, then make controlled adjustments to pose parameters.

6.5 Set Reasonable Ranges for Joints

Human movement should not be achieved through arbitrary rotation. You can define approximate ranges of motion for joints such as the shoulder, elbow, hip, and knee, and constrain rotation axes.

The value of these limits is not to accurately simulate medically correct human motion, but to avoid poses that clearly violate common sense, such as knees bending backward, elbows rotating along the wrong axis, or excessive head rotation.

7. Different Visual Styles Require Different Strategies

7.1 Icons and Cartoon Characters

If the goal is an icon, infographic, or low-detail animation, you can deliberately simplify the human body:

• Use a circle or ellipse for the head;
• Use a trapezoid for the torso;
• Use line segments or capsules for the limbs;
• Do not draw complex structures for hands and feet;
• Keep only the eyes and mouth on the face.

At this point, the focus is stylistic consistency rather than anatomical realism. Uniform simplification rules are usually more reliable than partial realism.

7.2 Low-Poly Characters

Low-poly style allows clear facets and simplified joints, but the skeleton proportions still need to be correct. You should first establish a reliable skeleton and then wrap it with fewer surface fragments, rather than directly stacking independent geometric primitives.

7.3 Realistic Characters

Realistic characters have higher requirements for topology, materials, lighting, and deformation, and it is usually difficult to achieve stable results by relying solely on a language model to write basic graphics code on the fly. A more reasonable solution is to use validated human templates, skeleton structures, and material pipelines, and let the model handle parameter adjustment, scene organization, and interaction code rather than deriving a complete human body from scratch.

8. Recommended Workflow for Development Practice

In real projects, large models can be positioned as “scene and code collaborators” rather than final renderers that require no verification.

A more reliable process is as follows:

Stage 1: Structure the Requirements

Break “draw a running person” into:

• Character style;
• Body proportions;
• Motion phase;
• Camera angle;
• Degree of facial visibility;
• Clothing complexity;
• Whether animation is needed;
• Whether interaction is needed.

Stage 2: Establish Skeleton and Constraints

First output the joint list, parent-child hierarchy, local positions, and rotation ranges. Do not rush to generate the full surface.

Stage 3: Generate Placeholder Volumes

Use simple geometric primitives to represent the head, ribcage, pelvis, and limbs, and confirm proportions and pose through the silhouette.

Stage 4: Automatic Checks

Check the following items:

• Whether left and right limb lengths are consistent;
• Whether joints are disconnected;
• Whether geometric objects severely penetrate each other;
• Whether both feet reasonably contact the ground;
• Whether the center of gravity falls near the support area;
• Whether facial features lie within the head region;
• Whether gaze directions are coordinated.

Stage 5: Progressive Refinement

After confirming the skeleton is correct, add surfaces, clothing, hair, and facial details. Each time a layer is added, keep a rollback-capable parameter version.

Stage 6: Establish Visual Feedback

Feed rendered results back into the analysis process so the model can modify specific parameters based on screenshots, keypoints, or detection results. Prompts should be as quantitative as possible, for example:

• “The right wrist is offset outward relative to the right elbow”;
• “The head width is too large relative to the shoulder width”;
• “The left foot is not contacting the ground”;
• “The gaze directions of the two eyes are inconsistent.”

This is more likely to produce effective corrections than a vague request to “make it look more natural.”

9. Conclusion

The fact that large models can generate buildings and natural scenes relatively well does not mean they truly understand architectural design or natural laws. The main reason is that these two types of objects are easy to express through modular geometry, repetitive structures, and controlled randomness, while also having high visual error tolerance.

Human figures are the opposite: body proportions are densely constrained, joint hierarchies are complex, surfaces require continuous deformation, facial features are highly sensitive, and human observers are extremely alert to any abnormality. For systems that generate graphics code from natural language, human figures are not simply “drawing a few more shapes” but a comprehensive problem involving geometry, kinematics, perception, and semantic coordination.

Therefore, the key to improving figure generation quality is not to endlessly add descriptive words, but to transform the task into a constrained, checkable, and iterative engineering workflow: build the skeleton first, then set proportions; check the silhouette first, then add details; use parameters instead of arbitrary coordinates, use validation rules to catch errors, and use visual feedback to form a closed loop. Only when the generation process evolves from “one-shot code writing” to “structured modeling with continuous verification” will large models’ performance on human figure drawing truly become stable.