From Bare Prompts to 3D Scene Delivery: An Engineering Practice for LLM-Based 3D Generation
This article documents an engineering approach to evaluating and delivering 3D scenes that large language models generate from a single bare prompt. Using a voxel-style detective-office miniature street scene as the test case, it examines three deliverables—an editable 3D project file, rendered images, and an interactive web page—and analyzes what the model got right, what it missed, and what it added on its own. It then presents a four-layer prompt template that turns vague "inspiration" into verifiable specifications, technical guidance for producing each deliverable, a combined machine-plus-human acceptance workflow backed by a weighted scoring table, and recommendations for managing over-delivery. The result is a reusable method for making prompt-driven 3D generation stable, controllable, and repeatable.
I. Background: 3D Generation Becomes a New Frontier for Capability Evaluation
Over the past while, the focus of LLM evaluation has quietly shifted. Code generation—representing “logic and syntax capability”—has been thoroughly tested, and people now care more about whether a model can turn natural language directly into visual output. As a result, 3D creation capability has moved to the foreground: given a paragraph of text, can the model build a structurally sound, stylistically consistent, editable scene inside professional 3D software, and go a step further to output an interactive web page? This tests more than “can it write code”—it demands integrated understanding of spatial structure, material style, text and signage, and scene detail. This kind of capability is usually summarized as “spatial reasoning.”
Such tests generally contain two parts:
- Asking the model to generate a miniature landscape inside open-source 3D creation software;
- Packaging the result into an interactive web page that runs in a browser.
The two have different tech stacks, delivery forms, and acceptance criteria. Put together, they cover the full “modeling—rendering—interaction” pipeline.
The shift in capability emphasis has also changed how we evaluate. 3D output can’t run unit tests automatically the way code can; it can only rely on multi-view screenshots, project file structure, and manual review. So I use a single “bare prompt” test as a sample: attach no skills, provide no reference image, input only a paragraph of natural language, and observe what the model delivers, what it omits, and what it adds on its own. The prompt and deliverables throughout are fictional demonstrations, and the names are generic placeholders. The goal is to distill a reusable method.
II. Test Design: From Scene to Delivery Form
2.1 Test Subjects and Tooling
- Task vehicle: a mainstream open-source 3D creation tool (referred to below as “the 3D tool”). It provides a Python scripting interface, letting the model batch-create meshes, set materials, place lights and cameras, and complete offline rendering.
- Interaction vehicle: a browser-based 3D rendering library built on native web graphics interfaces, responsible for turning the model into a draggable, rotatable scene in the page.
- Usage: load no skills, attach no plugins, provide no reference images—input only a paragraph of natural language, to reproduce the real path a regular user takes when “submitting a request—receiving a result.”
2.2 Scene Setup: A Recognizable Miniature Street Scene
The test scene is a two-story building with a second-floor agency office and a first-floor coffee shop, inspired by classic detective fiction. Its structure is fairly complete yet contains error-prone details such as signage text, character styling, and stair orientation—making it a good capability probe. There are four visual highlights:
- A street-facing “Detective Agency” sign;
- An exterior staircase on the side;
- A corner coffee shop on the first floor;
- Two characters at the entrance.
To eliminate stylistic ambiguity, the scene uses a unified voxel (cube-block) language: every shape is built from grid-aligned cubes, with colors drawn from a fixed palette.
2.3 Delivery Forms: Three Deliverables, Three Acceptance Views
- An editable 3D project file: tests editability, including object naming, hierarchy organization, material reuse, and polygon count.
- Static rendered images: tests fidelity and art quality, including composition, lighting, color, and key text.
- An interactive web page: tests interaction capability—whether the scene can be viewed and shared directly in a browser without professional software.
The three complement one another; judging by any one alone leads to a one-sided conclusion.
III. First Test Round: Performance, Omissions, and Unexpected Gains
3.1 First Delivery: Complete Structure, Lost Details
The first-round prompt was:
Please create a 3D voxel miniature landscape themed around a "Detective Agency" using open-source 3D software:Inspired by classic detective fiction, present the detective agency as a visual highlight in a voxel block language,and deliver an editable 3D project and rendered images.
The model delivered two rendered images and a 3D project file. Since the prompt didn’t mention a web page, I added a follow-up: “Open this file in a web page.”
In terms of fidelity, the overall result was passing: the exterior staircase leading to the second floor on the side, the second-floor agency space, and the first-floor corner coffee shop were all present, and two characters stood at the entrance.
But the biggest visual highlight was missing: the prominent “Detective Agency” sign on the agency’s wall did not exist in the model.
This is a typical case of “detail collapse” in 3D generation:
- The design signature wasn’t realized: The sign carries style and identity functions—equivalent to a brand mark or system logo—yet it is exactly the part the model is most likely to overlook.
- Text rendering has a higher bar: Getting the model to draw 3D text requires correct inner and outer font contours; generated lettering must be cleanly topologized so that after rendering the edges stay sharp with no broken faces.
- Long-sentence weighting gets diluted: In the prompt, the sign and style description were mixed with the overall requirements, so the model didn’t treat the sign as a standalone hard requirement.
Another lost point was the entrance characters’ hairstyles, which were hard to make out—a common “identity loss” after voxelization. Voxel models have limited precision, and fine curved surfaces like hair are hard to preserve, so viewers can’t tell who the character is.
3.2 Follow-up Delivery: Unexpected Gains in the Web Page
The prompt only asked to “open the file in a web page,” yet the page contained many features that were never explicitly requested:
- Basic interaction: mouse-drag rotation, scroll-wheel zoom, auto-rotation;
- Scene annotation: labels for each area floating at the corresponding position on the model;
- View focus: a sidebar listing views that jump in one click, with the camera smoothly transitioning after selection;
- Deliverable integration: a model download entry and switching between the two rendered images;
- First-time guidance: a drag hint on first open, so users don’t face a static image with no idea what to do.
View focus especially deserves mention. Before I clicked the label, I had no idea the character standing next to the model was the female one—the name actually became the clue to recognizing her.
These interactions aren’t just nice-to-haves. In scenarios like smart-building sandboxes, campus and park navigation, and city models, scene annotation and view focus are genuine necessities—effectively, the model has scaffolded the visualization prototype for the developer.
3.3 Interim Conclusion
| Dimension | Main behavior | Brief assessment |
|---|---|---|
| Spatial structure | Stairs, floors, and functional zoning relationships correct | Basic spatial reasoning capability present |
| Detail elements | Sign missing, character hairstyle low recognizability | Completeness is the main weakness |
| Style and rendering | Unified voxel style, render lighting and filter effects fairly good | Visually mature |
| Project file | Editable, imports and loads normally in the web page | Basically meets secondary-development needs |
| Interactive web page | Exceeded expectations, with annotation, focus, and guidance | High engineering completeness |
IV. Problem Attribution: Why Model Performance Is Uneven
Grouping the problems, they roughly fall into three categories:
- Semantic understanding bias: The prompt was more “inspiration-style” than “spec-style.” “Visual highlight” is a subjective expression, and the model can’t determine its concrete form or position in the frame.
- Difficulty balancing multiple constraints: The voxel style limits geometric precision, so the model must trade off between “keeping style consistent” and “restoring detail.” Complex elements like the sign are often simplified, or even omitted.
- Interaction implementation depends heavily on training data: Web interaction is patterned front-end engineering with abundant public code samples, so the model handles it with ease; scene-specific details like the sign lack a corresponding reference to draw on.
This yields one lesson: the precision of a prompt largely determines the usability of the generation result.
V. Prompt Engineering: Rewriting “Inspiration” into Verifiable Specifications
5.1 Four-Layer Prompt Template
【Role】Senior voxel scene designer【Task】Generate a voxel miniature landscape themed around a "Detective Agency" in open-source 3D software,and deliver: ① an editable 3D project file; ② ≥2 isometric-view rendered images;③ a standalone interactive web page.【Scene specs】- Style: voxel blocks, grid-aligned, base size 1×1×1, following the specified palette;- Building: two stories, cream walls + dark-gray roof; second floor is the detective agency, first floor is a corner coffee shop;- Layout: a side exterior staircase leads to the second floor; a "Detective Agency" sign hangs at the entrance (required element);the coffee shop has an awning, glass doors and windows, and outdoor tables and chairs; two characters stand at the entrance.【Hard acceptance criteria】1. The sign exists, is positioned correctly, and its text is readable;2. The staircase correctly connects both floors—not floating, not clipping through walls;3. The coffee shop roof does not block the sign.【Optional (non-hard)】Street props such as streetlights, benches, trash cans, and potted plants may be added as appropriate.【Output spec】- Name objects grouped by "Building/Interior/Props/Lighting/Cameras" for easy secondary editing;- The web page includes annotation, view focus, and drag guidance;- Before delivery, self-check each acceptance criterion, and explain the reason for any that fail.
5.2 Key Techniques
- Role and task: Give the model a clear professional identity so the output is closer to standardized engineering conventions.
- Spec-based description: Replace subjective words like “good-looking” or “has atmosphere” with objective parameters such as size, material, palette, and position.
- Explicitly list required elements: Put key elements like the sign on their own line and mark them “required element.” Even when the original vaguely says “use something as a visual highlight,” it should be made an explicit, standalone hard requirement.
- Separate hard vs. optional layers: Hard items are for acceptance scoring; optional items leave room for the model’s free play. The longer a prompt, the more easily its constraints dilute one another; explicit layering effectively reduces the chance that key information gets drowned out.
- Closed-loop self-check: Ask the model to check its output line by line before delivery—effectively giving it a round of “self-acceptance.”
- Complete the delivery form across rounds: Generating the model first and then adding “open it in a web page” does work, but the deliverable is then designed on the spot by the model, and consistency across generations is poor. Listing the web page as a deliverable in the first round, and specifying its interaction features, makes results comparable across multiple generations.
VI. Deliverable Breakdown: From “It Works” to “It’s Usable”
6.1 Editable 3D Project File
Naming and structure
- Use consistent prefixes for objects, materials, and collections, e.g.,
BLD_for building,INT_for interior,PRP_for props,LGT_for lighting, andCAM_for camera; - Suggested grouping:
Building/Interior/Props/Lighting/Cameras; - English naming avoids encoding issues when importing across software.
Modeling quality
- Voxel scenes should prefer instanced meshes or repeated units over building each block as an independent object. The latter multiplies the object count, makes editing hard, and greatly increases draw calls after importing to the web.
- Voxel geometry can be shaped quickly with boolean operations, but tolerances should be reasonable to avoid large numbers of zero-area, overlapping, or floating fragment faces.
- Secondary edits should prefer non-destructive methods such as modifiers.
Text signage
- 3D text must use a local font that supports Chinese, has complete glyphs, and has clear licensing;
- Note that the software relies on the runtime environment to locate system fonts, and some Chinese parsers require an explicitly specified font path; the delivery script should include the font file in the resource bundle to ensure reproducibility.
Asset setup
- Unify units, orientation, and origin;
- Reuse the same material for the same color block;
- Group lights and cameras into collections.
6.2 Rendered Images
- Isometric views suit showing overall structure; supplement with front and back views when necessary;
- Lighting should be mainly a key light plus ambient light; voxel scenes favor crisp hard shadows and soft indirect light;
- Post-processing can moderately adjust contrast and saturation, but the output must stay consistent with the project file—no “great images, poor model”;
- Deliver the render settings (resolution, sample count, color management configuration) to aid reproduction.
6.3 Interactive Web Page
A practical 3D showcase page is usually made up of five layers, as shown below:
Asset layer 3D transfer format / binary geometry / compressed textures / rendered images│Render layer scene & camera · lighting & shadows · tone mapping & post-processing · instancing│Interaction layer orbit controls · picking/highlight · auto-rotation · view keyframe transitions · drag guidance│Annotation layer anchor coordinates · world-to-screen projection · label avoidance · annotation config│Data layer model metadata / annotation data / view presets (stored separately from the model)
- Asset layer: Prefer an open 3D transfer format that supports PBR materials, scene nodes, and extension data; binary geometry is smaller and loads faster; use compressed texture formats where possible.
- Render layer: PBR materials, tone mapping, and post-processing determine the appealing, “filtered” look; instancing lets hundreds of voxel blocks produce only a few draw calls.
- Interaction layer: Auto-rotation and orbit controls are basic; view focus can be implemented with camera-position + target-point keyframes and easing interpolation; first-time drag guidance greatly lowers the user’s operational barrier.
- Annotation layer: Storing annotation data separately from the model means you can add, remove, or adjust text without touching the model—ideal for repeatedly iterated reporting scenarios.
- Data layer: This separation also means developers don’t need to work in professional software; editing one config file updates the annotation points and view list accordingly.
Taking annotation projection as an example, the core logic is converting 3D anchors into 2D label positions on the screen:
// Project a scene's annotation anchor to screen coordinates, for the HTML label layer to positionfunction projectToScreen(anchor, camera, viewport) {const ndc = anchor.clone().project(camera); // world coords -> normalized device coords// Don't show points behind the camera or outside the near/far clipping planesif (ndc.z < -1 || ndc.z > 1) return null;return {x: (ndc.x * 0.5 + 0.5) * viewport.width,y: (-ndc.y * 0.5 + 0.5) * viewport.height,};}
Engineering also requires three considerations:
- When labels overlap, hide lower-priority labels by priority, or use leader-line avoidance;
- Anchors occluded by buildings can be hidden using raycasting;
- Keep annotation and view presets in a separate configuration file for easy maintenance by non-developers.
6.4 Consistency and Accessibility
- Geometric consistency: The model loaded by the web page, the rendered images, and the project file should all come from the same version; use a content hash as a verification basis.
- Accessibility: When the model fails to load, show a static rendered image as a fallback; also provide keyboard operation, and respect the system’s “reduce motion” preference for dynamic effects like auto-rotation.
VII. Acceptance Methods: Turning Subjective Feelings into Quantifiable Scores
3D deliverables are hard to accept automatically, but you can design a “machine-check + human-check” workflow:
- Structural checks on the project file: object naming, grouping, polygon count, material count, and the presence of key objects.
- Manual review of the rendered images, checking each hard acceptance criterion.
- Functional acceptance of the web page: load time, interaction frame rate, whether annotation and focus work, and whether first-time guidance displays correctly.
- Weighted scoring per the table below.
| Dimension | Weight | Scoring points |
|---|---|---|
| Requirement fidelity | 30% | Key elements complete, spatial relationships correct, text and signage clearly legible |
| Style consistency | 15% | Voxel grid aligned, palette unified, no style mixing |
| Editability | 20% | Naming conventions, clear hierarchy, material reuse, controllable polygon count |
| Render quality | 10% | Composition, lighting, color, and detail presentation |
| Interaction experience | 15% | Load speed, operation smoothness, usefulness of annotation and focus |
| Engineering completeness | 10% | Deliverables complete, entry points clear, guidance on first use |
Using this article’s scene as an example, the first-round delivery can be scored like this:
- Requirement fidelity deduction: missing sign, low character recognizability;
- Interaction experience and engineering completeness bonus: web page features exceed the requirement.
The final score therefore reflects not only the “exact replication” ability but also the extra value the interaction layer brings. The key is to write both the deductions and the bonuses into the review record, so every comparison has a traceable basis.
VIII. Over-Delivery: The Right Way to Handle Unexpected Features
A model giving more features than requested isn’t always bad, but it needs engineering-minded management.
Value: Annotation, view focus, and drag guidance are exactly high-frequency needs in 3D visualization. If the model generates them in one shot and the quality passes, it saves developers the time of writing the interaction layer. The premise is a clear code structure with data and logic separated, so later text changes and model swaps don’t require touching the interaction code.
Risks:
- Features may deviate from real needs, adding maintenance cost;
- Auto-rotation, shadows, and post-processing stacked together may slow the frame rate on mobile devices;
- The field structure the model generates may not match the business system.
Practical suggestions:
- Explicitly specify which interactions are needed and which are not in the prompt;
- Do a “configurability” refactor of the model’s extra features—replace hardcoding with switches and configuration;
- Distill good interaction patterns into an internal team component library.
IX. Capability Boundaries and Implementation Suggestions
Overall, current 3D generation capability shows these traits:
- Strong at: overall layout, block massing, and a stylistically consistent scene language;
- Loses points on: small text and signage, complex character modeling, and high-frequency repeated structures;
- Surprise: the interaction layer’s engineering completeness often exceeds what the prompt asked for.
I offer three implementation suggestions:
- Spec-ify prompts: Organize them in four layers—specs, hard acceptance, optional, and output spec.
- Engineer the interaction layer: Specify the interaction plan in the prompt, and do a unified configurability refactor of the model-generated code.
- Systematize acceptance: Use a scoring table to constrain each generation result, forming a “generate—accept—feedback” loop.
In broader scenarios, this method applies equally well. For a smart-park sandbox or city model, you can emphasize asking the model to add:
- Floor labels and functional annotations;
- Blocks color-coded by business type;
- One-click focus views of key buildings.
For real-time rendering performance, cross-platform adaptation, or large-scale batch generation, using an elastic container platform to schedule rendering tasks, archiving outputs in object storage, and tracking task success rate and duration through a monitoring and alerting system can help teams turn experimental generation into sustainable, reliable productivity.
X. Outlook: From “Can Generate” to “Deliverable”
3D generation is becoming a touchstone for measuring LLMs’ spatial capability. Its difficulty isn’t in the visuals but in breaking one sentence into coordinates, materials, hierarchy, and acceptance criteria—and keeping consistency across both the mesh level and the pixel level.
For developers, the key is no longer “can the model make it” but “how to design prompts, deliverables, and acceptance criteria so that generation results are stable, controllable, and reusable.” Polishing prompt templates, interaction specs, and scoring systems around this pipeline offers more long-term value than chasing a single generation result.
