The gap between "describe a chair" and "generate a 3D chair" is closing fast. But the gap between that and "design a chair" - one you can modify, manufacture, or iterate on - is a different problem entirely. And it's the one that actually matters for anyone doing real design work.

I've been sitting with this problem while building SpellShape, an AI-native parametric design platform. The central question isn't "can AI produce something that looks like a chair?" It's "can AI produce something I can actually work with?" That question is why many teams - including mine - are moving away from "generate the final mesh" toward "generate the logic that produces the mesh." That shift is what this article is about.

Why 3D Is Unforgiving

Text-to-image works because images tolerate approximation: a slightly wrong pixel rarely "breaks" the picture. 3D is different. A usable 3D model is not just appearance - it's structure: watertight surfaces (for printing), clean topology (for animation), consistent normals (for shading), and often meaningful parts (for editing).

Most common exchange formats (OBJ, STL, glTF) ultimately reduce geometry to explicit vertices, faces, UVs, materials, and metadata. That explicitness is a strength for interoperability, but it's a challenge for generation: one missing index can corrupt a face list, inconsistent winding can flip normals, and tiny numeric drift can create cracks.

A useful mental model is rendering vs. construction. An image model can "cheat" perspective, hide errors in texture, or blur details. A 3D model can't: the moment you try to boolean, retopologize, rig, or manufacture, the structure is tested. This is why 3D generation isn't just "images, but with depth."

The Token Bottleneck

LLMs are strong at language and code, but a raw mesh is a long stream of numbers and indices. Asking an LLM to emit a complete OBJ is like asking it to write a phone book of floating-point coordinates without losing consistency. Even if the model understands "chairness," it still has to maintain thousands of locally and globally consistent constraints: symmetry, manifoldness, part boundaries, thickness, and so on.

This isn't only a quality problem - it's a representation problem. Many LLM pipelines fail not because "the AI is dumb," but because the output space (huge numeric lists) is poorly matched to the model's strengths (symbolic structure, patterns, hierarchies). That mismatch is what the "token bottleneck" means in practice: too many brittle tokens, not enough stable semantics.

Some research explicitly attacks this by making meshes more "LLM-readable." LLaMA-Mesh: Unifying 3D Mesh Generation with Language Models, for instance, explores representing vertex coordinates and face definitions as plain text so an LLM can be fine-tuned to generate and interpret meshes in a unified format. That direction is important - but it also highlights the underlying challenge: if the model must still produce a large amount of low-level geometric detail token-by-token, it will always be fighting length, consistency, and error accumulation.

Recipes, Not Dishes

A more designer-friendly approach is to stop asking for the final mesh and instead generate the procedure that creates it. Rather than outputting raw geometry, the AI produces structured “design logic”. This mirrors the evolution of 3D tools: artists didn’t abandon polygons, but wrapped them in higher-level systems like modifiers, constraints, parametric features, and procedural modeling. These systems compress intent — “make it taller,” “add fillets,” “repeat bays” — into controllable parameters.

LLMs are better at generating this kind of compact, structured description than thousands of precise coordinates. A short “recipe” can deterministically expand into complex, editable geometry, letting you tweak parameters instead of re-prompting from scratch.

Recent research follows this pattern. MeshCoder, LLMto3D, and ShapeCraft all treat the LLM as a generator of structured code or parameterized instructions, not raw meshes. Similarly, in SpellShape, the LLM outputs structured JSON design logic, which a deterministic engine converts into geometry — keeping results editable, inspectable, and adaptable to different modeling contexts.

Working on SpellShape pushed me toward a variant of this idea. The "recipe" there is JSON - a structured, compact description of operations, relations, and parameters - rather than a general-purpose language like Python. The LLM produces that JSON "design logic," and a deterministic engine interprets it into actual 3D geometry. This keeps generation in a constrained, inspectable space (schemas, typed fields, explicit dependencies), while still allowing expressive parametric editing. I've also been exploring how to let the LLM choose between modeling approaches based on design context - switching between procedural pipelines for organic forms versus hierarchical assembly for furniture, or using constraint solvers when relationships matter more than exact dimensions.

What's Still Hard

Even with these advances, several challenges remain stubborn:

• Ambiguous prompts - "chair" could mean a Barcelona chair, a plastic IKEA stool, or a wireframe art piece; style inference from minimal text is still unreliable

• Complex organic forms - without massive libraries of expert-designed generators, truly freeform shapes remain difficult

• Novel invention - current systems interpolate between known forms rather than genuinely inventing new ones

• Visual feedback loops - research like CADCodeVerify shows 96.5% compile rates with render-critique-refine loops versus 73.5% without, which means iteration is essential, not optional

Why the Representation Is the Innovation

If 3D AI remains stuck at "pretty but frozen meshes," it will mostly serve preview images and quick concept art. The moment the goal is design - iterating, editing, validating, building - systems need structure, constraints, and parameters. That's why the most interesting development right now isn't better geometry. It's a better representation of intent. The shift from "LLM generates everything" to "LLM as intelligent conductor" - small, focused operations with the LLM providing the glue - is what separates tools that produce images of chairs from tools that let you design one.