LLM 3D Scene Generation: Delivery Quality and Evaluation Practices
This article examines how to evaluate large language models on 3D content creation, using a bare-prompt test of a voxel-style "Street Corner Office" microscale scene as a running example. It walks through the rationale for bare-prompt testing, how to write effective first-pass and supplementary prompts, a delivery review that treats scene fidelity as the primary yardstick, the extra capabilities an auto-generated interactive web page can provide, a scoring methodology that separates baseline requirements from over-delivery, practical quota management for resource-heavy 3D tasks, and a plan for follow-up tests. It is aimed at practitioners who want to assess LLM-generated 3D assets and turn them into dependable production output.
Background: The Evaluation Focus Shifts from Code to 3D Creation
Over the past two years, code generation has been the primary yardstick for measuring a large model’s engineering ability. Completing functions, fixing defects, and writing unit tests can all produce objective feedback within seconds on whether the code runs.
Lately, the evaluation lens has been extending to 3D creation, for three reasons:
- 3D tasks simultaneously involve spatial reasoning, geometric expression, visual aesthetics, and engineering usability, making them a higher-order test of overall capability.
- Demand for 3D content is strong across games, film and television, architectural design, and smart-city scenarios, which gives directly generated output greater commercial value.
- The acceptance criteria for 3D results are more dimensional. Beyond “looks right,” the result must also “be editable” and “be interactive,” which supports a multi-layered evaluation system.
Mainstream large models have all made moves in 3D creation. Some platforms already offer multiple delivery formats such as models, web pages, and printable models, and support display details like auto-completed operation guides and annotations. Evaluation methods therefore need to be upgraded in step: shifting from “can it generate?” to “can it reproduce the key elements?”, “are the deliverables usable?”, and “is the interactive experience complete?”
Test Design: Using Bare Prompts to Probe 3D Generation
Design Principle: Minimizing Uncontrolled Variables
The core principle of this test is the “bare prompt”: no skills or extensions are attached before the formal request, and no reference image is provided. The goal is to observe how the model plans, executes, and fills in details for a 3D scene when there are no external constraints.
There are three reasons for choosing bare prompts:
- They faithfully reproduce typical usage. Most business users, when trying generative tools, will only type a one-sentence description rather than writing out detailed parameter specifications in advance.
- They expose real shortcomings. External skills often compensate for a model’s own weaknesses; only by removing external dependencies can you see where the boundaries actually lie.
- Results are reproducible and comparable. Rerunning the same prompt at different times and across different versions yields results that can be compared directly side by side.
Topic Selection: Concrete Visual Style and Scene Elements
This test uses a microscale scene inspired by a “Street Corner Office.” The topic has three advantages:
- The architecture has clear visual highlights: a two-story street-facing building with an external staircase on its side leading up to the second floor, where the office is located, while the café occupies the first floor.
- The scene elements are rich and verifiable. The staircase, the two functional floors, the street-facing storefront, and the characters can each be checked item by item.
- The visual style is distinct. The voxel aesthetic and the blocky expression of anime scenes fit naturally together, so the criteria for judging the result are relatively clear.
First-Pass Prompt: Stating Only the Necessities
The first-pass prompt states only the necessary conditions, without imposing constraints on the implementation:
Create a 3D microscale landscape in voxel style, themed around a"Street Corner Office." Take inspiration from the street-corner officein anime, with the main office building as the visual highlight,expressed in the language of voxel blocks. Deliver an editable 3Dproject file and a render.
This prompt implies four key requirements:
- Theme and inspiration source: defining the overall temperament and narrative backdrop of the scene.
- Visual subject: making clear that the “office building” is the visual center of the image, so the model does not spread its attention across irrelevant elements.
- Mode of expression: requiring the language of voxel blocks, which effectively specifies the basic modeling unit and the style constraint.
- Delivery format: requiring two kinds of output — an editable project file and a render. The former is for later modification; the latter is for quick preview and reporting.
The first pass actually delivered 2 renders (in PNG format) and 1 3D model file. Only at this point did the user realize the prompt had not mentioned an interactive web page, and added a follow-up line:
On the basis of the 3D model, also generate a web page that can beopened online and interacted with.
The second pass delivered the interactive web page. The final deliverables compared against the requirements are shown in Table 1.
| Deliverable | Corresponding Requirement | Exceeded Expectations? |
|---|---|---|
| Editable 3D model file | Editable 3D project file | No |
| 2 renders | Renders | Exceeded in quantity — a positive over-delivery |
| Online interactive web page | Openable in a browser | Exceeded — rich interaction |
Writing Supplementary Prompts: Specify the “Input,” Not the “Implementation”
The phrase “on the basis of the 3D model” is crucial. It does not specify a technical route, yet it makes clear the data source for the web page, so the model naturally builds the page on top of the model it has already generated. Supplementary requirements are best written with the following template:
On the basis of 【existing deliverable】, generate 【deliverable name】,for 【use case】, with the following 【2–3 core requirements】.
Example 1: Supplementary requirement prompt template
On the basis of the generated 3D model, generate an interactive web pagefor a touchscreen demo at the sales site.Requirements:1. Support mouse or touch rotation, zoom, and pan;2. Add name labels to each functional area of the building;3. Show a brief operation guide the first time it is opened.
This style of writing does not hand implementation details to the user, yet it guides the model toward producing a page that fits the business scenario more closely.
Delivery Review: Fidelity Is the First Yardstick for 3D Generation
Once you have the render, the first thing to do is check each prompt requirement against the finished product item by item, as shown in Table 2.
| Prompt Requirement | Output | Assessment |
|---|---|---|
| Voxel block style | The entire scene is built from regular blocks | Met |
| External staircase to the second floor | Generated | Met |
| Second-floor office | Generated | Met |
| First-floor café | Generated | Met |
| Two characters at the entrance | Generated, but one character is hard to identify | Partially met |
| Office as the visual highlight | The main building lacks a sign; weak identity | Not met |
Overall, the skeleton of the scene is faithfully reproduced, but the “finishing touch” element that carries the theme is missing, so a perfect score is not warranted. Three points deserve closer examination.
(1) What is missing is an identity marker, not an ordinary component.
A “sign” occupies a very small share of the image in voxel terms, and it is cheap to replace, so it is easily dismissed as a trivial detail. But in this kind of scene narrative, the sign is what pins down the theme. Without it, a viewer can only tell that this is “a two-story building,” not that it is a “street-corner office.”
This type of error is far more damaging in engineering terms than as a visual shortcoming. A model-generated scene contains many objects, and they are often named ambiguously, which makes it costly to manually track down “what is missing where” later. If a structural component is missing, it is obvious at a glance on the render; but when a naming-type small object is missing, it often goes unnoticed until a client points it out.
The lesson here is that every noun in the prompt should be verified item by item during acceptance.
(2) Abstract character styling affects recognizability.
The voxel style is inherently highly abstract, and details such as hair and facial features are hard to fully express with a small number of blocks. So when representing a character with blocks, the hair silhouette and signature colors often become the only identifying cues.
If the model omits these cues when generating characters, the characters lose their identity in the image, which not only hurts fidelity but also breaks the narrative completeness of the scene. For scenes centered on people, the identifying features of the characters should be stated explicitly in the prompt.
(3) Theme presentation follows a “whole first, details later” tendency.
A complete skeleton with missing markers indicates that the model is more inclined to first build a “recognizable spatial structure” and then fill in details step by step. This strategy is efficient for one-shot generation, but the completeness of the details depends on whether the prompt describes them adequately.
There are two directions for improvement:
- On the requirements side: break the scene into several “acceptance units,” and for each unit specify the name, position, quantity, and form.
- On the tooling side: add a “requirements cross-check” step before the model delivers, in which the model self-checks against the prompt item by item for missing pieces, and auto-fills and re-delivers where necessary. This is a common engineering-enhancement approach, not an inherent capability of a specific model.
Example 2: Acceptance unit checklist in the prompt
Scene acceptance units (please ensure all are included):1. Building overall: a street-facing two-story building built from voxel blocks;2. External staircase: on the side of the building, leading from the firstfloor to the second;3. Second-floor office: a "Street Corner Office" sign hanging on thestreet-facing wall, with the text spelled out in voxel blocks and clearlylegible in the image;4. First-floor café: tables, chairs, and an awning placed at the entrance;5. Characters: a man and a woman at the entrance, each retaining theirsignature hairstyle and colors.
This checklist can be written into the prompt, or used as an item-by-item verification table once the finished product is in hand.
Interactive Web Page: An Over-Delivery Bonus
The supplementary prompt mentioned only “openable online” and did not state any interaction requirements, yet the resulting web page is quite complete in functionality.
The basic interactions include drag-to-rotate, scroll-to-zoom, and auto-rotation. In addition, there are several advanced features:
- Scene annotations: name labels displayed next to functional areas such as the building and the staircase, repositioning automatically as the viewpoint changes.
- View focus: a sidebar listing the key elements of the scene; clicking one automatically points the camera at that target.
- Operation guidance: a drag hint shown on first open, lowering the barrier to entry.
- Deliverable integration: model download entry, render switching, and image filters, all included.
In real business use, these features map directly onto concrete scenarios, as shown in Table 3.
| Web Feature | Technical Implementation | Business Value |
|---|---|---|
| Drag, zoom, auto-rotate | Basic camera controller | View the model from any angle |
| Scene annotations | Bind 3D coordinates to label positions | Automatically “write captions” for the model |
| View focus | Camera position and orientation presets | Quickly locate key areas |
| Operation guidance | First-load hint layer | Lower the barrier for non-expert users |
| Model download, render switching | Resource links and image carousel | One-stop access to deliverables |
Taking annotations as an example, the principle is to maintain a mapping of “scene object name to 3D coordinates,” project the 3D coordinates onto screen coordinates at render time, and then draw the labels. Example 3 is a simplified illustration.
Example 3: Simplified implementation of scene annotations
// Simplified illustration: scene annotation based on "object name + 3D coordinates"// Scene elements: key is the name, position is the 3D coordinateconst hotspots = [{ name: 'Office', position: [0, 4.2, 2.6] },{ name: 'Café', position: [0, 1.2, 2.8] },{ name: 'External staircase', position: [2.8, 2.1, 0] },];// Recompute each label's screen position whenever the camera changes each framefunction updateLabels(camera, viewport) {hotspots.forEach((item) => {// 1. Project the 3D coordinate into normalized device coordinates (NDC)const ndc = item.position.clone().project(camera);// 2. Convert to pixel coordinatesconst x = (ndc.x * 0.5 + 0.5) * viewport.width;const y = (-ndc.y * 0.5 + 0.5) * viewport.height;// 3. Hide the label when the point is behind the camera (z > 1) to avoid wrong projectionitem.element.style.display = ndc.z > 1 ? 'none' : 'block';item.element.style.transform = `translate(${x}px, ${y}px)`;});}
View focus describes the camera setup with a “target point + camera distance,” and Example 4 is a simplified illustration.
Example 4: Simplified implementation of view focus
// Simplified illustration: after clicking a name, the camera smoothly moves to a preset positionfunction focusOn(focus) {// focus.target is the target point, focus.distance is the camera distance,// the camera advances along the current line of sightconst direction = camera.position.clone().sub(controls.target).normalize();const nextPosition = focus.target.clone().add(direction.multiplyScalar(focus.distance));// Use eased interpolation instead of an instant switch to improve the experienceanimateTransition(camera.position, nextPosition, 0.6);animateTransition(controls.target, focus.target, 0.6);}// Share the same element list with the annotations to keep names consistentdocument.querySelectorAll('.focus-item').forEach((el) => {el.addEventListener('click', () => {const focus = focusList.find((f) => f.name === el.dataset.name);if (focus) focusOn(focus);});});
This code example also reveals an important rule: automated generation is only the starting point, and engineering fixes matter just as much. Auto-generated code usually gets the main flow working, but it often has problems under edge conditions — for example, a label may be projected incorrectly when the point is behind the camera, or the camera may jump abruptly during a switch. These problems only surface when tested case by case against real interaction scenarios.
This also explains why, in smart-visualization projects, scene annotations are more practical than in anime-style scenes. Projects such as stock-market dashboards, city modeling, and park planning generally feature “many elements with tangled names,” where manually adding annotations one by one is time-consuming and laborious. Auto-generated annotations can significantly shorten the cycle from modeling to a demonstrable state.
Evaluation Criteria: Scoring “Over-Delivery” and “Missing Elements”
The most typical characteristic of this delivery is “missing one thing, adding a pile of others”: the core identifier was missing, yet a large amount of unrequested functionality was added. If you evaluate simply by “number of features,” you are likely to reach an overly optimistic conclusion. A more reliable approach is to assess “whether it meets the original requirements” and “whether it exceeds expectations” separately.
Setting the Baseline: Passing on Requirements, Excelling on Experience
This evaluation combines a baseline with experience weighting, with results shown in Table 4.
| Dimension | Baseline (Determines a Pass) | Experience Weighting (Determines the Score) |
|---|---|---|
| Scene fidelity | Office sign, external staircase, second-floor office, first-floor café | Character recognizability, richness of scene detail |
| Model engineering | Project file opens, objects editable | Whether object naming and grouping are clear |
| Render quality | Complete renders, no obvious broken faces | Composition, lighting, and filter aesthetics |
| Interactive web | Web opens, model displays correctly | Annotations, view focus, operation guidance, model download |
By this criterion, the model file meets the “editable” requirement, but the scene fidelity was missing an identity item, so not all baseline items passed, and a perfect score is therefore not warranted.
The web page, beyond the baseline items, additionally provides several experience capabilities such as annotations, view focus, operation guidance, and downloads. None of these were required in the original prompt, so they count as positive over-delivery and should be treated as a bonus rather than a “default obligation.” Conversely, if some version removed these features, it should not be judged a failure — only that it did not reach the level of excellence.
Distinguishing “Over-Delivery” from “Gilding the Lily”
Whether extra features count as a bonus depends on whether they serve the original goal:
- When a 3D microscale landscape is used for displaying a scene, auto annotations and view focus help viewers understand the content, making them a valid increment.
- If a task only needs a static render but is stuffed with interaction controls unrelated to display, that instead increases maintenance cost and should be regarded as redundant.
Therefore, the clearer the requirement description, the more accurately over-delivery can be judged. A vague prompt blurs “over-delivery” and “misunderstanding the requirement,” making them hard to tell apart.
From Ad Hoc Impressions to a Reusable Scorecard
This evaluation exposed a common problem: without a unified standard, assessments of generated results tend to stay at subjective impressions like “does it look like it?” or “is it good-looking?” It is advisable to distill a reusable scorecard, as shown in Table 5.
| Dimension | Weight | Scoring Focus |
|---|---|---|
| Theme fidelity | 30% | Whether every acceptance unit in the prompt is present |
| Spatial structure | 20% | Whether spatial relationships (floors, stairs, doors, windows) are correct |
| Style consistency | 15% | Whether voxel granularity and color scheme are consistent |
| Model engineering quality | 15% | File opens, objects editable, clear naming and grouping |
| Render presentation | 10% | Complete composition, lighting, and material expression |
| Interactive experience | 10% | Operation smoothness, annotation accuracy, load speed |
Weights should be adjusted to the specific business. Projects aimed at presentation and reporting can raise the weights for rendering and interaction, while asset production for later secondary development should raise the weight on engineering quality.
Quota Management: Spending Credits Where They Matter
3D generation tasks are generally “heavy”: a single task must complete scene planning, geometry generation, render output, and web development, consuming far more quota than plain text conversation. This test had just ended when the daily quota was already used up, and the next planned scene had to be deferred to the following day. Without planning, quota is easily burned on pointless trial and error. The following five practices are worth considering.
- Prompt first, dry-run before running. Before formally submitting, have the model rewrite the prompt into a structured scene breakdown, confirm that the acceptance units are complete, and only then start generating — reducing the “generate, discover a gap, regenerate” cycle.
- Queue tasks by priority. Use a task list to record the topics to be tested, the required delivery formats, and their priorities, and execute them in order once the quota is restored.
- Keep a quota ledger. Record the consumption of each task, the type of deliverable, and the number of rework attempts, to identify which steps consume the most quota and optimize prompts and workflows accordingly.
- Split tasks, easy before hard. Generating “model + render + interactive web page” all at once is resource-intensive. You can generate the model first, confirm it is correct, and then add the web page requirement. This lowers the cost of a single failure and makes it easier to pinpoint which step the problem lies in.
- Retain process artifacts. Archive prompts, generation results, and evaluation conclusions together to form a searchable knowledge base, so the next similar task can start at a much lower cost.
Example 5: Task list and execution status illustration
from dataclasses import dataclass, field@dataclassclass SceneTask:theme: str # Scene themedeliverables: list # Expected deliverables, e.g. ["model", "render", "web"]status: str = "pending" # pending / running / review / doneattempts: int = 0 # Number of rework attempts, to locate quota-heavy stepsnotes: list = field(default_factory=list)# Task queue: scenes missing a sign get retested firstqueue = [SceneTask("Street Corner Office (add sign)", ["model", "render", "web"]),SceneTask("Real estate sandbox", ["model", "web"]),SceneTask("Smart city block", ["model", "web"]),]def run_daily(queue, daily_quota):used = 0for task in queue:if task.status != "pending":continueif used >= daily_quota:print("Daily quota exhausted; remaining tasks deferred")breaktask.status = "running"task.attempts += 1used += 1# Hook up the actual generation call here, and record deliverables and review conclusionstask.status = "review"task.notes.append(f"Run {task.attempts} generated; submitted for review")return used
Next Testing Plan and Lessons Learned
Building on these results, the next phase can proceed in three directions.
(1) Repair testing for missing key elements. Regenerate the same scene with a prompt that includes the acceptance checklist, focusing on whether the model can correctly generate the sign and embed it in the image. This is effectively a controlled experiment that directly tests “whether a structured prompt can compensate for insufficient fidelity.”
(2) Expanding to city-scale scenes. Try scenes such as real-estate sandboxes and smart-city blocks, focusing on:
- The model’s ability to organize large-scale voxel scenes;
- The usability of annotations and view focus in complex scenes;
- The relationship between generation time and quota consumption.
(3) Verifying the usability of printable models. When testing printable-model generation, focus on whether the model is watertight, whether the wall thickness is reasonable, and whether the structure is stable, accumulating experience for desktop 3D printing and similar applications.
This test can be summarized in three points.
- Bare prompts test the “default capability.” With external aids removed, the model’s ability to build spatial structure is already quite solid, but identity-marker details of the theme can still be omitted.
- “Annotations + focus” is a standard feature of auto-generation. These capabilities happen to fit the “many elements, tangled names” characteristic of smart-visualization projects, and are among the first value points where 3D generation can land in industry scenarios.
- Engineering practices are indispensable. Acceptance checklists, structured scoring, and quota ledgers are the key to turning generation results into stable productivity, and should be solidified into the team’s standard workflow going forward.
