Driving LLMs with Bare Prompts to Generate 3D Miniature Scenes

    This article reports an experiment that uses a single bare prompt—no plugins, no external asset libraries—to have an LLM generate an editable 3D voxel diorama of a "detective agency" street scene, along with multi-camera renders and a single-file interactive webpage. It breaks down the five-stage text-to-3D generation pipeline, analyzes why the most prominent element (the signage) was dropped while interactive features were over-delivered, and provides a six-dimension evaluation rubric, a table of common failure modes with prompt-fixing strategies, a self-check pattern, and practical guidance for turning one-off generations into a stable, reusable production pipeline.

    1. The Evaluation Shift: From Code Correctness to Spatial Expression

    Over the past two years, LLM capability benchmarks have revolved almost entirely around one question: “can it write code that runs?” Algorithm problems, SQL queries, script refactoring, unit-test completion. But once code generation reaches the platform and engineering stage, syntax correctness alone can no longer tell models apart. What truly separates them is a different class of problem: whether a model can maintain structural coherence, reasonable proportions, and semantic completeness in three-dimensional space.

    We can broadly call this spatial reasoning and scene-construction capability. The difficulty is not “writing one correct line of code” but holding three layers of constraints simultaneously:

    • Geometric constraints: floor heights, bay widths, continuity of stair treads; components must not intersect or float in the air.
    • Semantic constraints: when the user says “detective agency,” the model must understand this as a composite of “street-facing shop + upper-floor office + outdoor stairs + signage,” not an ordinary block building.
    • Style constraints: a unified voxel language across the entire scene, a consistent grid scale, and readability even under an orthographic view.

    Upgrading the generation task from “write a script” to “deliver an editable 3D work” is therefore a more rigorous way to test a model’s spatial capability.

    2. Experiment Design: Bare Prompts, Explicit Deliverables, Verifiable Criteria

    This experiment deliberately imposed three constraints to rule out confounding variables:

    1. No skills or plugins attached, and no external asset libraries used, to avoid “retrieval-based success.”
    2. A single-turn bare prompt, with no multi-turn correction, to test the information density of the first generation.
    3. An explicit deliverables list, requiring editable project files, multi-camera renders, and an interactive webpage that opens directly in a browser.

    The prompt itself follows a seven-part structure—role, goal, style, spatial constraints, key elements, deliverables, and acceptance criteria:

    1. Role: Senior 3D scene builder
    2. Goal: Generate a miniature urban-block diorama on the theme "detective agency"
    3. Style: Unified voxel-block language, 1×1×1 grid, compatible with both
    4. orthographic and 45° perspective views
    5. Spatial constraints: Two-story building, floor height of 4 grids; outdoor stairs
    6. connecting the street level to the second-floor platform;
    7. ground floor is a street-facing shop, second floor is the agency,
    8. with a projecting awning on the front facade
    9. Key elements (must not be omitted):
    10. 1. A horizontal sign across the top of the front facade, with text built
    11. block by block from voxel glyphs, guaranteeing legibility
    12. 2. No fewer than 5 details: stair railings, door handles, AC outdoor unit,
    13. mailbox, awning, etc.
    14. 3. Two voxel character models, placed at the entrance and on the stair
    15. platform respectively
    16. Deliverables:
    17. A. Editable project file: objects independently named, grouped into
    18. the collections "Building / Street / Props / Characters"
    19. B. Two renders: 45° perspective + front elevation
    20. C. A single HTML file with the model and all interactive scripts embedded
    21. Acceptance: List item by item whether each key element landed; explain the
    22. reason for any that are missing

    The core design idea of this prompt is to make implicit common sense explicit as verifiable items. The most common reason a bare prompt fails is not a lack of model capability, but that a key element is “not prominent enough” semantically—what matters most to the user often shows up in natural language as nothing more than a qualifier.

    3. Dissecting the Generation Pipeline: The Five-Stage Text-to-3D Flow

    From an engineering perspective, a successful 3D generation goes through roughly five stages:

    1. Scene semantic parsing: expand the natural-language theme into a scene graph (building / street / props / characters), and infer parent-child relationships and orientation.
    2. Spatial layout reasoning: determine the coordinate origin, orientation reference, and the bounding boxes and relative positions of each element, handling occlusion and connectivity.
    3. Scripted modeling: instantiate voxels parametrically and write them back to project files through the 3D software’s scripting API.
    4. Material and lighting configuration: converge the color palette (12–20 colors suits a voxel style), combine directional and ambient light, and add contact shadows.
    5. Rendering and frontend packaging: render from multiple cameras, convert model formats, and bundle everything with the interactive scripts into a single-file webpage.

    Pseudocode makes the modeling stage more intuitive:

    1. # Pseudocode: voxel scene assembler (a generic abstraction of the 3D tool's scripting API)
    2. scene = VoxelScene(grid=1.0, origin=(0, 0, 0))
    3. # 1) Building body: number of floors, floor height, and bay width are all
    4. # parameterized for easy re-editing
    5. for level in range(2):
    6. z0 = level * FLOOR_HEIGHT
    7. scene.add_box(f"building.wall.{level}",
    8. size=(12, 8, FLOOR_HEIGHT),
    9. offset=(0, 0, z0),
    10. material="plaster")
    11. # 2) Outdoor stairs: instantiate treads one by one, group railings separately
    12. for i in range(STAIR_STEPS):
    13. scene.add_box(f"stair.tread.{i:03d}",
    14. size=(3.0, 0.8, 0.35),
    15. offset=(-6.0 - i * 0.8, -4.2, i * STEP_RISE))
    16. # 3) Key elements: generate the sign from a glyph bitmap to avoid
    17. # "the text element disappearing entirely"
    18. for idx, bit in enumerate(VOXEL_GLYPH["OFFICE_SIGN"]):
    19. if bit:
    20. scene.add_box(f"sign.voxel.{idx:03d}",
    21. size=(0.4, 0.4, 0.2),
    22. offset=SIGN_ORIGIN + idx * 0.4,
    23. material="sign_red")
    24. scene.commit() # Write back the project file, preserving object-level editability
    25. scene.render(views=["iso_45", "front"]) # Batch multi-camera rendering

    Three things in this pseudocode stand out: parameterization (floor height and number of treads are changeable rather than hardcoded), naming conventions (a Collection.Category.Index structure, which directly determines whether the frontend can do object-level focus), and explicit mapping from semantics to geometry (translating “signage text” into a glyph bitmap instead of leaving it to the model’s free play).

    4. Observations: Acceptable Fidelity, but Missing Key Elements

    Looking at the actual deliverables, structural and semantic fidelity sits at a “good” level: the outdoor stairs, the second-floor agency, the first-floor street-facing shop, and the two placeholder character models at the entrance are all in place. The spatial relationships are not obviously disordered, the voxel style is consistent, the render filters are clean and clear, and the overall look is better than most comparable attempts.

    But there are two typical defects worth analyzing separately.

    First, the signage is entirely missing. This is the most conspicuous element in the whole scene and the most “fatal” point of failure—it is both the visual focal point and the only textual anchor for theme identification. There are usually two reasons: one, when “detective agency” is treated as a composite theme, the model shifts its attention to the larger building and street volumes and judges the sign to be an accessory detail; two, text geometry essentially requires glyph data, and if the model does not explicitly take a “bitmap / curve-extrusion” path, it tends to skip it rather than approximate.

    Second, semantic drift in the characters. Voxelization is itself a highly compressed form of representation; head blocks, hairstyle contours, and clothing color patches are highly prone to ambiguity at 16³ to 32³ resolution. The result holds at the level of “this is a female character,” but fails at the level of character identity recognition—it even takes frontend annotation text to reverse-infer the role. This suggests that under a voxel style, semantics that depend on fine distinction—such as characters—should be reinforced through annotation or palette contrast, not expected to explain themselves through geometry alone.

    5. An Unexpected Win: The Interactive Webpage’s “Over-Delivery”

    More noteworthy than the 3D model itself is the webpage output. The prompt only said “open the file in HTML,” yet the model proactively filled in a whole set of interactive capabilities:

    • Orbit drag and auto-rotation: basic camera orbit control, with damping and an auto-cruise mode.
    • Scene annotation: text labels anchored to key components on the model.
    • View focus: a sidebar listing focusable objects in the scene; clicking one smoothly transitions and centers the camera.
    • Asset integration: model-file download and switching between multiple renders.
    • First-entry guidance: a floating layer prompting “hold and drag to rotate,” lowering the cold-start cost.

    Among these, scene annotation and view focus carry the most engineering value. They are essentially a general technique of “3D anchor + screen-space projection”:

    1. // Pseudocode: annotation anchoring = project 3D coordinates into screen space, with frustum clipping
    2. function syncAnnotations(camera, anchors, viewport) {
    3. const p = new Vector3();
    4. anchors.forEach(a => {
    5. p.copy(a.world).project(camera); // world coordinates -> normalized device coordinates
    6. const x = (p.x * 0.5 + 0.5) * viewport.width;
    7. const y = (-p.y * 0.5 + 0.5) * viewport.height;
    8. a.el.style.transform = `translate(${x}px, ${y}px)`;
    9. a.el.style.opacity = p.z > 1 ? 0 : 1; // hide when outside the frustum / occluded
    10. });
    11. }

    With a small amount of adaptation, the same mechanism can be reused directly for property showcase visualization, urban-planning displays, equipment digital twins, and campus or park navigation: swap the anchors from a “detective agency example” to “building—area—average price” or “equipment—temperature—alert,” and swap the sidebar from a focus list to a legend and filters—the interactive skeleton needs no rewrite at all. This also explains why “the model does a little more on its own” is often more valuable in real projects than “strictly following instructions”—what it delivers is actually an interaction paradigm, not merely an asset.

    One caveat, though: interaction code auto-generated by a model cannot go live directly in a real project. You must add resource-loading strategies (model chunking and geometry compression, first-screen lazy loading), fallback paths for low-end devices, decoupling of anchor data from business APIs, and unified error handling.

    6. Evaluation Rubric: Six Dimensions for Scoring 3D Generation

    To avoid the subjective judgment of “it looks nice, so give it a high score,” it is better to score with a structured rubric:

    Dimension Weight Key criteria
    Key-element recall 30% Whether all elements explicitly listed in the prompt landed, and whether missing ones explain the reason
    Structural coherence 20% Floor-height and stair continuity, no component intersections, no abnormal bounding-box overlaps
    Style consistency 15% Consistent grid scale, palette count, and lighting; readable in orthographic view
    Editability 15% Object naming, collection grouping, degree of parameterization
    Interaction completeness 10% Robustness of camera control, annotation, focus, download, and guidance
    Delivery completeness 10% Whether the project file + multi-camera renders + single-file webpage are all present

    Measured against this rubric, the conclusion of this experiment is: interaction and delivery completeness are near full marks, editability is above average, but key-element recall fails—so the overall score should not be high. Missing one sign cuts the work’s theme-recognition in half. That is the highest-weighted item, and it cannot be compensated for by excellence in the other dimensions.

    7. Common Failure Modes and Prompt-Improvement Strategies

    Failure mode Root cause Improvement strategy
    Signage / text labels entirely missing Insufficient element prominence; no glyph data Explicitly state “text must be built from voxel bitmap,” and specify font size and pixel height
    Semantic drift in character modeling Voxel compression loses detail Lower expectations for identity; distinguish roles via annotation text or a high-contrast palette
    Scene component proportion distortion Grid and floor height not specified Fix the grid scale, and describe dimensions in “grids” rather than “meters”
    Chaotic object naming, impossible to focus No constraint on project organization Specify a naming template and collection divisions
    Hardcoded coordinates, not reusable No requirement for parameterization Require “sizes and quantities via variables, no scattered magic numbers”
    Webpage has only the model, no interaction Vague deliverables description List interaction items and acceptance methods in the deliverables list

    The accompanying engineering technique is to have the model self-check. You can build in a round of automatic validation that outputs a health report after generation:

    1. report = {
    2. "required_objects": {"sign": False, "stairs": True, "cafe": True},
    3. "bbox_overlap": [], # Abnormal bounding-box intersection detection
    4. "grid_violations": 0, # Count of non-integer-grid coordinates
    5. "material_count": 14, # Whether the palette has converged
    6. "editable_ratio": 0.82, # Share of objects with compliant naming
    7. }
    8. print(report)

    This self-check turns “does it look right” into “does the data say it’s right,” which is especially important across multiple rounds of iteration.

    8. From a Single Generation to a Reusable Pipeline

    If this kind of generation is to enter production, it needs a stable pipeline rather than relying on the luck of a single conversation:

    1. Access layer: separate the prompt templates from business parameters (project name, number of floors, style, annotation fields) and version-control the templates.
    2. Scheduling layer: rendering is CPU-intensive, so use a message queue to make generation tasks asynchronous, and let the container platform elastically scale rendering nodes by queue length to avoid request timeouts.
    3. Artifact layer: store project files and renders in object storage and accelerate first-screen loading with a content delivery network; apply geometry compression and chunking to model files on demand.
    4. Observability layer: integrate logging and monitoring alerts, and track metrics such as “key-element recall rate,” “average generation time,” and “credits consumed per task,” so quality fluctuations are traceable rather than based on gut feeling.

    It is worth flagging the quota and consumption issue. 3D generation is inherently resource-hungry—script execution, multi-camera rendering, and model conversion are all heavy operations, and a daily limit can be exhausted within a few deep attempts. A sensible strategy in practice: first run a “low-resolution + single-view” smoke test to validate the structure and key elements, and only then execute the full render after confirming the prompt is correct; cache templates for scenes that have already been validated, recompute only the parameters that changed, and reuse the rest. This both significantly reduces consumption and makes A/B comparison of prompt effects executable.

    9. Conclusion

    The most informative part of this experiment is not how well the model performed, but what it exposed: in 3D scenes, the weight of “explicitness” far exceeds that of “subtle expression.” That sign you care about most will likely be dropped if, in the prompt, it is only a background qualifier; conversely, interaction capabilities you never mentioned may be proactively filled in by the model.

    The takeaways for developers can be summarized in three points: first, turn key elements from descriptive sentences into an acceptance checklist so that omissions can be quantified; second, use naming conventions, parameterization, and self-check scripts to turn “outputs” into “maintainable assets”; third, adopt a multi-dimensional rubric in evaluation so that structural defects are not masked by visual completeness. The mark of maturity in spatial-reasoning capability is not prettier renders, but structural coherence, complete elements, editable assets, and reusable interaction—only when all four are met does it deserve a high score.