Testing LLM 3D Creation: From Prompt Design to Full Deliverable Workflow
Large language models are increasingly being evaluated on 3D generation tasks built around toolchains like Blender and Three.js. This article walks through a hands-on test of generating a voxel-style miniature diorama from a bare prompt, analyzes the deliverables for structural accuracy and detail fidelity, and distills the findings into a reusable five-layer evaluation framework covering structural correctness, detail restoration, engineering usability, productization, and cost.
Why 3D Generation Is Becoming a New Benchmark for LLM Evaluation
Recently, the focus of LLM capability evaluation has been shifting. Traditional benchmarks centered on code completion and algorithm pass rates are no longer effective at differentiating top-tier models—performance on general-purpose code generation has become remarkably similar across mainstream models. As a result, the community and vendors are turning to more complex tasks that better reflect real production scenarios: 3D modeling and visualization based on toolchains such as Blender scripts and Three.js.
3D creation is considered a more discriminating test for three main reasons:
- Higher spatial reasoning barriers. 3D scenes require the model to understand geometric relationships, hierarchical structures, and proportions—far more complex than generating flat code. For a building model to “look right,” it must correctly handle the position of staircases, the relationship between floors, and the orientation of characters at the entrance. Any spatial logic error is immediately visible to the naked eye.
- Multi-step deliverables test engineering capability. A complete 3D deliverable typically includes the model project file, rendered images, and an interactive web page, testing whether the model can organize output across tools and formats.
- Requirement understanding and proactive completion. User prompts rarely spell out every detail. Whether the model can fill in missing functionality within reasonable bounds—such as interaction controls or scene annotations—directly determines the completeness of the deliverable.
A Hands-On Test: Generating a 3D Voxel Miniature Diorama with a Bare Prompt
Test Design
To get as “clean” an evaluation as possible, I used a bare prompt: no skill plugins, no reference assets—just a natural language description of the task. The prompt was roughly as follows:
Please create a 3D voxel miniature diorama themed around a detective agency.Inspired by a classic anime scene, make the agency the visual highlight,render it in voxel-block language, and deliver an editable Blenderproject file along with rendered images.
Several considerations went into this prompt. First, I specified the art style (voxel) to constrain the visual language and prevent the model from wavering between realism and cartoon aesthetics. Second, I defined the deliverable format (project file + rendered images) to enable objective acceptance testing. Third, I deliberately left some room for the model to exercise its own judgment.
Deliverables and Fidelity Analysis
The model delivered two rendered images and an editable 3D model file. In terms of structural fidelity, the key architectural elements of the scene were largely complete: a side staircase leading to the second floor, the agency office upstairs, a coffee shop on the ground floor, and even character figures placed at the entrance.
But a typical problem also surfaced: the most recognizable visual element was missing—the prominent signage on the wall was not generated. This highlights an important evaluation perspective: fidelity assessment should not just measure “element coverage rate” but also “key element priority.” A model that covers 80% of the elements but lacks the signature one looks dramatically different from one with evenly distributed completeness. This is why automated metrics alone cannot replace manual review.
There was also an interesting detail: the character figures’ hairstyles deviated noticeably, making them nearly impossible to identify from appearance alone. This reflects a current weakness in fine-grained semantic understanding—the model can handle structural instructions like “place two characters,” but it captures stylized character features imprecisely.
Exceeding Expectations: Proactively Adding an Interactive Web Page
What truly exceeded expectations was the HTML page the model produced when I asked it to present the results in a web page. It packed in a number of features I never requested:
- Basic interactions: drag-to-rotate and auto-rotation display—these were within expectations;
- Scene annotations: labeled explanations of key elements in the model. This feature is highly practical for smart visualization scenarios (real estate sandboxes, city modeling, digital twins of industrial parks)—a textbook case of “correct proactive completion”;
- Focus on view: a side panel listing key scene elements, where clicking one focuses the camera on the corresponding position. The only issue was that element names didn’t match their actual appearance, further confirming the fine-grained semantic weakness;
- Deliverable integration: the model file download entry and a rendered-image switcher were built into the page, forming a self-contained results showcase;
- Onboarding guidance: a drag-operation tutorial on first launch, showing consideration for the end user experience.
This part of the test shows that top-tier models already demonstrate strong product thinking in “requirement extrapolation”—they don’t just execute instructions, but understand task intent and proactively fill in sensible features.
From a Single Test to a Methodology: How to Systematically Evaluate 3D Capability
Based on this exercise, I’ve distilled a reusable evaluation framework:
Layer 1: Structural correctness. Check whether geometric elements are complete and spatial relationships are sound. Explicitly listing the key elements in the prompt makes item-by-item acceptance easier.
Layer 2: Detail fidelity. Focus on the quality of signature elements. Use a “key element priority ranking” approach—mark the elements that best represent the theme as P0 and verify them first during acceptance.
Layer 3: Engineering usability. Check whether the generated model file is editable, whether formats are standard, and whether it can be imported into mainstream toolchains for further work. There is still a gap between a file that “opens” and one that is truly “usable”—inspect mesh structure, material naming, and layer organization.
Layer 4: Interaction and productization. If the deliverable includes a web page, evaluate the completeness and soundness of the interaction design, and check whether the model’s proactive feature additions align with real needs.
Layer 5: Cost and quotas. 3D generation tasks consume far more tokens than ordinary conversations, and quota limits are an unavoidable practical constraint. Before committing to a full project, run small-scale tasks to estimate per-run cost, then budget for batch production accordingly. Many developers report that newly released models often have tight quotas in their early days; this typically eases as services stabilize. Users of model service platforms—such as Baidu AI Cloud—should also pay attention to the platform’s quota policies and multi-model routing capabilities, using alternative models to distribute peak demand.
Final Thoughts
This test gave me a more nuanced picture of current LLM 3D creation capabilities: structured scene building has reached a usable level, and the proactive completion of interactive web pages is occasionally delightful—but fine-grained semantic fidelity and prioritization of key elements remain clear weaknesses. For developers, rather than agonizing over whether a model can “do it perfectly in one shot,” it’s more productive to treat the model as a junior collaborator that needs clear acceptance criteria: use structured prompts to set boundaries, use tiered acceptance checklists to control quality, and rely on manual work to polish critical details. That may well be the right way to collaborate effectively with 3D generation models at this stage. I’ll be running follow-up tests on more complex scenarios (such as real estate sandboxes and smart city modeling)—stay tuned.
