3D Scene Generation with Bare Prompts: A Practical Workflow and Evaluation Framework
This article explores what happens when you drive a general-purpose large language model with a deliberately minimal "bare" prompt to produce an editable 3D voxel scene. It walks through the experiment design, a six-dimension evaluation method that turns subjective visual impressions into concrete scoring items, and a real case study of a detective-office miniature. The model reconstructed the multi-floor spatial structure well but silently dropped key identifying elements such as the exterior signboard and individualized character details. The article explains why bare prompts miss these elements, then offers a structured five-part prompt template, an acceptance checklist, a three-round iteration strategy, and engineering guidance for turning a single generation into a deliverable asset. It closes with a conclusion and two directions for follow-up work.
1. Background: 3D generation is becoming a new benchmark for LLMs
Over the past two years, judging how “smart” a general-purpose large model is has mostly meant looking at its coding ability—whether it can write correct algorithms, read error messages, and complete engineering functions. The appeal of this kind of benchmark is that it is easy to automate: run the test cases, and the pass rate is the verdict. But as leading models converge on standard programming benchmarks, differentiation is shifting toward capabilities that no single metric can fully capture: 3D content generation and spatial reasoning.
There are three reasons for this:
- Spatial reasoning is a composite ability. To generate a building, a model has to handle relative position, hierarchical structure, occlusion, proportion, materials, and lighting all at once. That is more constrained dimensions than generating a piece of compilable code.
- Validating a 3D deliverable is expensive. Code correctness can be decided by a compiler, but a 3D scene spans geometry, semantics, rendering quality, and editability—mixing subjective and semi-objective dimensions. This tends to expose a model’s “depth of understanding” rather than its “pattern memory.”
- There is real industrial demand. Smart-city sandboxes, real-estate project visualizations, digital prototypes of industrial equipment, training and education scenes, and 3D e-commerce displays used to depend on professional artists and modelers producing output over days or even weeks. This is being compressed by a “natural language → editable 3D asset” paradigm.
It is worth noting a clear recent trend in the industry: the delivery format is evolving from “a single rendered image” into a combination of “editable engineering file + multi-angle renders + interactive webpage.” This essentially upgrades 3D generation from an “image task” to an “engineering task,” raising the bar for a model’s structured output ability.
2. Experiment design: Why stick to “bare prompts”
The core variable of this practice is how complete the prompt is, not how feature-rich the platform is. That is why it deliberately adopts what the industry calls “bare prompts,” meaning:
- No preloaded skills, templates, plugins, or knowledge bases are attached;
- No reference images, storyboard sketches, or reference geometry files are provided;
- The first-round prompt does not enumerate delivery formats or acceptance criteria, in order to observe the model’s “default gap-filling ability”;
- Missing delivery formats (an interactive webpage) are added only in a single follow-up round.
A sample of the prompt used is as follows:
Using a desktop-grade 3D modeling application, create a 3D voxel(voxel block) miniature diorama themed around a "detective agency,"drawn from the agency scene in a classic mystery anime. Make theagency building itself the visual highlight, rendered consistentlyin a voxel-block language. Deliver an editable 3D engineering fileand rendered images.
There are several deliberate “weak constraints” in this text:
- Abstract theme: “detective agency” specifies no floor count, orientation, or color scheme.
- Single visual anchor: “make the agency the visual highlight” is an evaluative description, not a computable geometric constraint.
- Partially specified deliverables: only the engineering file and renders are mentioned; the webpage is not.
The goal of this design is to observe whether, without explicit specs, the model will proactively invoke “commonsense scene knowledge” to fill in details, and whether it will proactively expand the delivery format.
3. Evaluation dimensions: Breaking subjective impressions into discussable items
Simply saying “it looks decent” has no engineering value. In practice, I recommend splitting this kind of task into six dimensions, each scored independently and backed by concrete evidence:
| Dimension | Focus | How to judge |
|---|---|---|
| Semantic completeness | Whether key elements that commonsense expects to be present appear in the scene | Check against an element list item by item |
| Geometry and spatial structure | Whether floor count, stairs, openings, and massing proportions are reasonable | Compare across multi-angle renders |
| Fidelity of form | Recognizability of characters and props | Naming blind test (can it be identified without being told the name) |
| Material and rendering quality | Consistency of the voxel language, lighting, tone, overall look | Subjective rating + render time logged |
| Engineering editability | Whether it is a native engineering structure that can be layered and modified | Open the project and check the object hierarchy |
| Delivery completeness and interactivity | Whether a webpage, interactive features, and extra information layers are provided | Check against a feature list |
Among these, the naming blind test for “fidelity of form” is especially worth recommending: first withhold what an object is supposed to be, then let the evaluator identify it on their own. This method quickly exposes false fidelity—things that “look right but can’t be recognized.”
4. Actual results: A good but imperfect delivery
4.1 What scored well: the structural fidelity was genuinely solid
The model delivered two bitmap renders from different angles and one editable 3D engineering file. From the renders, the structural relationships of the main building are largely correct:
- The external staircase leading to the second floor was modeled correctly, with position relationships matching the reference impression;
- The second-floor agency space and the first-floor retail space were clearly distinguished;
- The first floor was treated as a coffee shop, complete with an awning and a street-facing frontage;
- Two character voxel models of the main characters were placed at the entrance.
In other words, the model did not simply “stack a box of cubes”—it understood the composite spatial archetype of “a two-story building + an external staircase + a shop at the base.” This is direct evidence of spatial reasoning ability.
4.2 What was deducted: the most critical semantic anchor was missing
In the original anime, the agency’s exterior wall carries a conspicuously sized signboard that directly serves as the scene’s “identity marker.” This signboard did not appear in the model.
This is the most noteworthy issue in the evaluation, for these reasons:
- It is not a “detail” but a semantic anchor—remove it, and the scene degrades from “a particular detective agency” to “some two-story building with a staircase”;
- It is a high-frequency, visually prominent element that co-occurs strongly with this theme in the training corpus, so in theory it belongs to the part that is “easiest to memorize”;
- Its absence shows that, during voxelization, the model prioritized preserving structural geometry (stairs, floor height, bay width) while discarding the flat, graphic identity information.
A reasonable inference is that the voxel modeling paradigm has an implicit preference for volume and structure, whereas a text signboard is a combination of “thin slab + texture text”—hard to express at voxel resolution and requiring additional texture or character-geometry generation ability. For the model, this task calls for an explicit “text-bearing object modeling” decision, and the bare prompt did not trigger it.
4.3 What was deducted: insufficient recognizability of the characters
Of the two characters at the entrance, the long-haired female character’s hairstyle was clearly distorted; her identity was only confirmed after checking the object names in the interactive page. This indicates that the model still leans toward a “generic cartoon human” convergence for fine character features, and that individualized traits (hairstyle silhouette, clothing color-block division) are not well preserved.
In industrial practice this kind of problem is controllable: characters are often replaceable “independent assets” within a scene, and can be solved by swapping in library assets or through secondary modeling—there is no need to demand complete generation in a single pass.
4.4 What earned bonus points: capability spillover into the interactive webpage
After adding the single instruction “open this file in a webpage,” the model returned not a crude 3D viewer but a fairly complete interactive page:
- Basic interaction: drag to rotate, auto-rotation, zoom;
- Scene annotation: text labels mounted in 3D space, pointing to specific objects;
- View focusing: a sidebar lists three clickable objects; clicking one smoothly moves the camera to focus on the corresponding component;
- Artifact integration: the page provides a download entry for the model file and a toggle between the two renders;
- Onboarding hint: a drag-operation tip appears after loading, lowering the barrier to use.
Here is an easily overlooked value point: scene annotation + view focusing is essentially a lightweight framework for 3D information visualization. In scenes such as real-estate sandboxes, city modeling, park/zone planning, and industrial equipment descriptions, “click a list item → camera focuses → attributes displayed” is the core interaction paradigm. The fact that the model spontaneously produced this structure without an explicit instruction shows that it has accumulated a good prior over the component patterns of “3D display applications.”
At the same time, the tone and filter treatment of the renders reached a level of visual quality that could be used directly in reporting materials—work that in the past would usually have required artist rework.
5. Problem attribution: Why bare prompts miss key elements
Abstracting these observations, we can reconstruct the basic working pipeline of such models:
Natural-language prompt↓ Semantic parsingScene theme and style vector↓ Commonsense completion (implicit)Scene element list (scene graph, implicit and invisible)↓ Geometric instantiationVoxel/mesh geometry + materials + camera↓ Rendering / interaction packagingRendered images + engineering file + webpage
The key problem lies in the third step: the element list is generated implicitly by the model; the user can neither see it nor intervene in it. This produces three typical failures:
- Salience mismatch. The model completes “structurally necessary items” (able to stand, able to go upstairs, able to enter the shop) rather than “recognition-necessary items” (the signboard, the address plate, the signature color scheme). The former determines whether the scene holds together; the latter determines whether the scene can be recognized.
- Expressiveness bottleneck. Thin-slab text, semi-transparent glass, slender pipes, and similar elements carry a high cost in a voxelization framework and are easily silently omitted—and the model will not proactively tell you “what I omitted.”
- No acceptance criteria. The prompt gives only a theme and style, with no enumeration of “which objects must appear,” so the model naturally converges on its own priors.
The corresponding engineering solution is straightforward: make the implicit list explicit, and make subjective descriptions verifiable.
6. Reusable practice: Structured prompts and an acceptance checklist
6.1 Structured prompt template
Upgrading the prompt from “a single description” to a “five-part structure” can significantly reduce the rate of missing elements:
[Theme] Detective agency; two-story building; first-floor retail is a coffee shop[Style] Voxel-block language; uniform grid size; low-poly characters[Required element list]1. Two-story main building + external staircase (connected passage)2. First-floor shop: door, windows, awning, street-side table and chairs3. Exterior signboard: a sign with legible text (must appear)4. Two characters: an adult male and a long-haired female, standing at the entrance[Spatial constraints] Building faces south; camera initial view is a 3/4 overhead angle[Deliverables] Editable 3D engineering file / two renders from different angles /interactive webpage (with drag, auto-rotation, scene annotation, view focusing)[Acceptance criteria] Check the required element list item by item; a single missing item requires iteration
The “required element list + acceptance criteria” are the core. They turn the model’s implicit scene graph into an explicit checklist, so that during iteration the user can state clearly “what to add” rather than vaguely saying “make it look more like it.”
6.2 Iteration strategy
In practice, it is not advisable to pursue perfection in a single pass. A more effective path is three-round convergence:
- Round one: structural validation. Focus only on whether spatial relationships and massing proportions hold up, accepting missing materials and details.
- Round two: element completion. Add instructions item by item for the elements missing from round one, especially signage-type, text-type, and recognizable-feature-type elements.
- Round three: delivery format and interaction enhancement. Add engineering layering, material conventions, interactive features, and annotation information, turning the asset into a deliverable product.
7. Engineering implementation: From demo to deliverable
A single generation is only the starting point. To apply this capability to real projects, four more links must be completed:
- Asset generation and normalization. Standardize grid size, origin, orientation, naming conventions, and hierarchy, so that results from multiple generations can be consumed by the same codebase.
- Asset storage and distribution. 3D models, textures, and renders are large, so they are typically placed in object storage and delivered through a content delivery network; compress model files and use tiered loading (low-poly first screen, high-poly for interaction) to control load time.
- Interaction layer deployment. A 3D webpage is mostly static resources with client-side computation, making it suitable for container platforms or static hosting, with canary releases and version rollback.
- Observability. Wire in logging and monitoring/alerting, and focus on first-screen load time, interaction frame rate, model download success rate, and page error rate—experience problems in 3D applications almost always surface in performance metrics first.
In enterprise scenarios, these capabilities are usually organized in a platform-based way—for example, through Baidu AI Cloud’s large-model service platform and its supporting development toolchain—to handle model invocation, quota management, invocation log retention, and resource monitoring in a unified way, avoiding each team maintaining its own evaluation and scheduling scripts.
One more engineering reality to keep in mind: invocation quotas and concurrency limits directly affect the pace of evaluation. These multi-round, long-context, output-heavy tasks consume resources quickly. It is advisable to plan evaluation batches in advance, assign different themes (buildings, parks, cities, machinery) to different time windows, and retain the first-round prompts and outputs as a regression baseline for later model-version comparison.
8. Conclusion and next steps
This practice of “bare prompt + one follow-up question” yields three takeaways:
- The spatial-structure capability of 3D generation already has practical value. Composite spatial archetypes such as multi-story buildings, connecting staircases, and functional zoning can be reliably reproduced by the model, meeting the basic requirements of an editable asset.
- The shortcomings concentrate on “identifying elements” rather than “structural elements.” Text signboards, individualized character features, and thin-wall components are currently the parts most easily silently omitted, and must be backed up by an explicit element list.
- The value of the delivery format has been underestimated. The scene annotation, view focusing, artifact integration, and onboarding hints that the model spontaneously completed show that “3D content + a light interaction framework” can already be planned as a standard deliverable, not just an accessory to a rendered image.
Therefore, the reasonable attitude toward this kind of task is not to give a single overall score, but to establish an evaluation method of “element list + acceptance criteria + three-round convergence.” Under this framework, this delivery can be given a high score on the structural dimension and a deduction on the semantic-completeness dimension, with the instruction items to be added in the next round spelled out clearly.
Two lines of follow-up work are planned: first, expand themes horizontally to cover scenes closer to industrial needs—real-estate sandboxes, smart-city blocks, industrial equipment prototypes—with a focus on annotation systems and attribute-attachment ability; second, deepen constraints vertically by introducing multi-round structured prompts and automated acceptance scripts, turning “looks good” into “passes item-by-item verification.”
