Office Hours — Why can image generation models create complex scenes like Super Mario levels but struggle with precise technical drawings like robot ramp designs?

Why can image generation models create complex scenes like Super Mario levels but struggle with precise technical drawings like robot ramp designs?

The Training Data Problem Is Real But Only Part of the Story

Image generation models train on billions of internet images. Those images skew heavily toward photographs, artwork, memes, and design mockups that humans find visually interesting. A Super Mario level is a culturally iconic pattern that appears thousands of times in training data, often paired with detailed descriptions. A technical drawing of a robot ramp? It exists in a much smaller corpus, often buried in CAD files, engineering PDFs, and proprietary datasets that never made it to the public web. The model has simply seen fewer examples of what precise technical geometry actually looks like.

But that’s not the real bottleneck. The deeper issue is what the model is optimizing for.

What These Models Actually Learned to Do

Image generation models learn to predict “what comes next” in pixel space by matching statistical patterns in training data. For artistic scenes, the training data rewards creativity, semantic coherence, and visual appeal. A Super Mario level needs to look playable and fun. The model learns that clouds go in the sky, pipes are specific shades of green, and platforms stack in recognizable ways. Those are loose constraints. The model can fudge details and still generate something humans find satisfying.

Technical drawings impose a different constraint: metric precision. A ramp designed to support a 50kg robot load at a 30-degree angle requires exact proportions. If the height is off by 2cm, the physics breaks. If the support structure doesn’t align with the weight distribution, it fails catastrophically. These aren’t aesthetic preferences, they’re hard physical requirements. Image generation models don’t learn to optimize for those because their training signal is visual plausibility, not physical correctness.

Why Spatial Reasoning Fails at Scale

There’s another layer: spatial reasoning under constraint. Generating a Super Mario level means the model learns rough spatial relationships. Platforms should connect, pipes should fit on the ground. But those are loose spatial relationships with lots of tolerance for error. A robot ramp design requires tight tolerance across multiple interacting dimensions simultaneously. The ramp angle must match the load specifications, the support beam cross-section must handle torque, the attachment points must align with existing frame geometry. That’s not a single constraint, it’s a system of coupled constraints.

Current image generation models don’t learn constraint propagation. They generate locally coherent details without tracking global dependencies. They can draw a ramp that looks like a ramp. They struggle to draw a ramp that is a ramp.

The Benchmark That Should Scare You

OpenAI’s recent StationeryBench results (noted in the Daily Signal) showed that GPT-6 Astra completed 7 out of 100 dual-arm robot manipulation tasks while competitors couldn’t finish any. That’s progress on spatial reasoning, but 7% completion on constrained robotics tasks is nowhere near production-grade. The capability exists but at a scale far below what technical work demands.

What Actually Works Right Now

If you need precise technical drawings today, you’re better off using a hybrid approach:

Start with parametric CAD generation (OpenSCAD, Python scripts using CadQuery) for the constrained geometry. This enforces your design rules.
Use an LLM to generate the parameters based on your requirements in natural language.
Render the CAD output.

Here’s a simplified sketch:

from cadquery import Workbench
import anthropic

client = anthropic.Anthropic()

# Step 1: Extract design parameters from natural language specs
specs = "Robot ramp for 50kg load at 30 degrees with aluminum frame"

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=500,
    messages=[{
        "role": "user",
        "content": f"""Extract CAD parameters for this design spec:
{specs}

Return JSON: {{"angle_degrees": X, "load_kg": Y, "frame_material": "Z", "height_mm": A, "width_mm": B}}"""
    }]
)

params = json.loads(response.content[0].text)

# Step 2: Generate CAD with hard constraints
def generate_ramp(angle, load, height, width, material):
    wb = Workbench()
    # CadQuery enforces geometry rules
    ramp = wb.box(width, height, 10).rotate((0, angle, 0))
    support_cross_section = calculate_beam_size(load, angle)
    support = wb.box(support_cross_section, support_cross_section, height)
    return ramp.union(support)

ramp = generate_ramp(
    params["angle_degrees"],
    params["load_kg"],
    params["height_mm"],
    params["width_mm"],
    params["frame_material"]
)

# Step 3: Render or export
ramp.save("ramp.step")

This approach separates the hard constraints (handled by CAD libraries that enforce geometry) from the semantic understanding (handled by the LLM). The LLM interprets language and picks parameters. The CAD engine guarantees the physics.

Why Image Models Can’t Bridge This Gap Soon

Fixing this would require retraining image generation models to optimize for constraint satisfaction, not just visual coherence. That means either building much larger datasets of constrained technical drawings (expensive) or finding a way to embed physical simulators into the training loop (computationally brutal). Neither is happening at scale. The low-hanging fruit in image generation is still photorealism and artistic style, not precision engineering.

Anthropic’s recent work on spatial reasoning (mentioned in Daily Signal coverage of reasoning benchmarks) shows that frontier models are getting better at structured, multi-step spatial reasoning. But that capability lives in reasoning models like Claude Opus 5 or GPT-6 Astra used as parameter extractors, not in the image generation pipeline itself.

Bottom line:

For technical drawings, don’t ask image generation models to be CAD tools. Use them to interpret design intent in natural language, extract parameters, and feed those into constraint-respecting CAD libraries. That hybrid approach works in production today; waiting for image models to learn precision engineering will cost you time and accuracy.

Question via Hacker News