Prompt Engineering and Acceptance Testing for LLM-Generated 3D Voxel Dioramas

    As large models improve, the question shifts from whether they can generate 3D voxel scenes to whether their output can actually be accepted into a production workflow. This article reframes evaluation around three criteria—semantic completeness, engineering deliverability, and interaction completeness—then breaks art requirements into four independently checkable constraint layers. It offers a three-part prompt template (role, spec checklist, delivery) with quantifiable acceptance conditions and mandatory self-checking, a standard three-piece deliverable (editable project file, renders, interactive web page), an explanation of the web viewer's completion role, a reproducible four-stage batch pipeline, and a five-dimension scoring rubric with blind review. The takeaway: turn prompts from prose into numbered checklists with measurable acceptance criteria, fix the deliverable set, and make the generation pipeline reproducible, rollback-able, and attributable.

    1. Redefining the problem: from “can it generate?” to “can it be accepted?”

    When people discuss whether a general-purpose LLM can produce a usable 3D miniature landscape right after an overnight version update, the conversation usually gets stuck on “does it look convincing?” But what really decides whether this capability can enter a production pipeline isn’t the appeal of a single rendered image. It’s three things:

    • Semantic completeness: Are the key elements explicitly named in the scene actually modeled?
    • Engineering deliverability: Can it produce an editable 3D project file, not just an image?
    • Interaction completeness: Does the deliverable come with a way for non-technical people to view it directly?

    A typical test result: the model could reproduce the externally mounted staircase, the second-floor office, and the first-floor street-facing café, and even placed two figures at the entrance. But the signboard—emphasized in the prompt as the main visual subject—was missing from the model. On that basis alone, the delivery doesn’t deserve a perfect score, because what’s missing is the element with the highest semantic weight in the scene. On the other hand, the supplementary interactive web page proactively implemented several capabilities that were never requested. This “model omits, web page compensates” mismatch is exactly what reveals the current capability boundary of the 3D generation pipeline: geometry generation is good at stacking volumes but weak on fine-grained semantic symbols, while the web wrapping layer is good at engineering completion and strong at packaging a half-finished product into a usable deliverable.

    2. Breaking art requirements into four verifiable constraint layers

    If you want the model to make fewer mistakes, the first step isn’t writing a longer prompt—it’s breaking the instruction “build a miniature landscape” into four layers of constraints that can each be verified independently. During evaluation, you should also score these four layers separately rather than assigning one vague overall score.

    Layer Focus Common failure modes
    Geometry Voxel granularity, proportions, passable stairs and door openings Voxels too coarse so the stairs can’t be walked; distorted floor-height and bay-width ratios
    Semantic Named key objects, text signage, figures and props Key markers entirely missing; detail-level semantic drift (figure styling doesn’t match the spec)
    Material & lighting Voxel color palette, material zoning, lighting and post-processing filters Entire scene in one color; inconsistent shadow direction; excessive render noise
    Interaction View control, annotations, focus, deliverable download No auto-rotation; missing scene descriptions; missing download entry point

    The value of this table is that it turns a subjective judgment like “does it look good?” into a locatable conclusion like “which layer failed?” A missing signboard is a semantic-layer failure; abstract figure hairstyles are detail-level semantic drift; and a nice-looking render filter is just a bonus on the material layer—the three cannot cancel each other out.

    3. Prompt template: a three-part structure of role, spec, and delivery

    Bare prompts easily miss key elements because a “theme word” in natural language gets treated by the model as a style cue rather than a hard requirement. Hit rate rises noticeably when you explicitly enumerate the key elements and bind them to acceptance conditions.

    1. [Platform and Role]
    2. You are a 3D scene construction engineer. Using the scripting interface of a general-purpose 3D authoring tool (headless CLI runtime + Python API),
    3. build a miniature diorama using a voxel language. Base voxel size: 0.05m; half-grid scaling allowed.
    4. [Scene Checklist (every item must be modeled; any missing item = failure)]
    5. 1. Three-story street-facing building: external staircase (steps >= 8, continuous handrail), second-floor office, first-floor street-facing café;
    6. 2. Facade main sign: a horizontal signboard whose text is fixed as "Corner Office"; it must exist as an independent geometry object;
    7. 3. Two figures at the entrance, standing pose, with a height-to-doorframe ratio of about 1:2;
    8. 4. No fewer than 3 street props (mailbox, street lamp, awning).
    9. [Rendering and Delivery]
    10. Output three PNGs from different camera positions (default view / 45-degree top-down / close-up detail),
    11. save an editable project file with all objects grouped and named in a parent-child hierarchy;
    12. also output an interactive page that opens in a browser.
    13. [Self-Check Requirement]
    14. Before delivery, verify the scene checklist above item by item, explicitly flag any missing items in the notes, and do not silently omit them.

    There are three key changes here: promoting the theme from “style description” to a numbered checklist, adding quantifiable acceptance conditions to key objects, and requiring self-checking with explicit error reporting. The third one matters most—it turns “silent omission” into “visible defect,” which is what makes evaluation meaningful.

    4. The three-piece deliverable set and the completion role of the web layer

    For real-world delivery, it’s best to fix the deliverable at three pieces: an editable project file, several renders, and an interactive web page. The first two serve professional review; the last serves non-technical demonstration. The web viewer should cover at least the following capabilities:

    1. // Pseudocode: lightweight WebGL-based viewer skeleton
    2. const scene = await loadScene('/assets/scene.bin'); // open 3D interchange format, binary packaging
    3. // 1. Orbit controls + auto-rotation
    4. controls.enableDamping = true;
    5. controls.autoRotate = true;
    6. controls.autoRotateSpeed = 0.8;
    7. // 2. Scene annotations: anchor description text to 3D coordinates, project to screen with the view
    8. annotations.forEach(a => {
    9. const p = project(a.position, camera); // world coordinates -> screen coordinates
    10. renderLabel(a.title, a.desc, p.x, p.y);
    11. });
    12. // 3. View focus: click a sidebar item to smoothly transition the camera position
    13. focusTo('Office, second floor');
    14. // 4. Deliverable download + image-set switching
    15. attachDownloadButton('/assets/scene-project');
    16. switchRenderImage(index);

    Scene annotations and view focus are the two most underrated capabilities here. Put yourself in delivery scenarios like sandbox models, real-estate models, and campus or park modeling, and you’ll find that the annotation layer turns a model from a “good-looking ornament” into an “explainable proposal,” while the focus layer saves reviewers from hunting for the right angle. Both are worth far more in engineering value than adding one more render. In addition, an onboarding hint on first entry (a drag-to-interact prompt) significantly lowers the entry cost for non-technical users—a low-cost, high-return addition.

    5. A reproducible batch production pipeline

    When this kind of request goes from “try it once” to “produce proposals in batches,” you can’t rely on clicking through everything by hand. A reproducible pipeline usually has four stages:

    1. Task definition: Write each scene’s checklist, voxel spec, and delivery format into a structured config (YAML recommended), kept separate from the generation code;
    2. Scheduling and execution: Containerize the generation tasks and let a queue consume them with a concurrency limit; per-scene timeouts and retry policies must be explicitly configured so long-tail tasks don’t drag down the whole batch;
    3. Artifact management: Store project files, renders, and interactive pages uniformly in object storage, organized into directories by scene ID, with pages referenced by fixed URLs so review links can be distributed directly;
    4. Observability: Log each task’s input summary, duration, and failure reason, and turn success rate, average duration, and retry count into metrics with alerting configured. On Baidu AI Cloud, these four stages can each map to general-purpose capabilities such as the container platform, message queue and object storage, and logging with monitoring and alerting—no need to build your own.

    Once you go to batch, the prompt template itself needs to be version-controlled. Differences produced by the same prompt across different model versions can only be explained if they’re recorded—otherwise, the moment a version updates, you won’t be able to tell whether it’s prompt regression or model regression.

    6. Evaluation: a five-dimension scoring rubric and blind review

    To avoid “I think it’s good” conclusions, evaluation needs structure. I suggest 20 points per dimension across five dimensions:

    Dimension Criteria
    Semantic completeness Hit rate of mandatory items in the numbered checklist (highest weight)
    Geometric soundness Whether proportions, voxel granularity, and structure/passability are self-consistent
    Material & rendering Color zoning, lighting consistency, output usability
    Interaction completeness Whether annotations, focus, download, and onboarding are all present
    Editability Whether the project is layered and named, and can be further modified

    Three evaluation disciplines: run the same prompt at least three times to avoid single-sample variance; blind-review multiple solutions with reviewers not seeing the model source; and record the difference between the first round and after follow-up prompts, to measure the ability to “fix defects through clarification.” The original phenomenon of “only getting the web delivery after adding one sentence” is a typical follow-up gain and should be counted separately.

    7. Conclusion

    The real level of 3D generation capability doesn’t depend on how stunning the render looks, but on whether key semantic elements appear reliably, whether the project file stays editable, and whether the interactive delivery covers explanation scenarios. The recommendation is direct: change prompts from descriptions into numbered checklists with quantifiable acceptance conditions, and require the model to self-check explicitly; fix the deliverable at project + renders + web page; and containerize the generation pipeline while connecting it to object storage, logging, and alerting, so batch production is reproducible, rollback-able, and attributable. Do these three things, and no matter how the underlying model iterates, you’ll hold a stable evaluation and production capability—which is more valuable than chasing any single release.