Evaluating AI-Generated 3D Scenes with Bare Prompts: From Code Generation to Interactive Scene Creation
AI evaluation for coding assistants has traditionally focused on code correctness, but generated code that runs does not always produce useful output. This article argues that 3D scene creation exposes a broader set of capabilities, including spatial reasoning, asset structure, style consistency, and interaction design. Using a deliberately minimal bare prompt, the test asks an AI system to create a voxel miniature detective-agency scene and deliver an editable 3D project, rendered images, and an interactive web page. The analysis covers structural completeness, missing key identifiers, acceptable stylization losses, generated annotations, camera-focus behavior, and engineering steps needed for production use. It also provides a prompt-writing checklist and an acceptance table for evaluating AI-generated 3D scenes.
1. Why evaluation is shifting from code generation to scene creation
Historically, the most direct way to evaluate a model or an AI coding assistant was to measure code correctness: whether an algorithm problem could be solved in one pass, or whether a runnable component could be produced from a requirement. Such tests are clear and automatable, but they have an obvious ceiling: code that runs is not necessarily useful.
3D creation fills that gap. Delivering a voxel miniature scene simultaneously tests four capabilities:
- Spatial reasoning: an outdoor staircase leading to the second floor must align with the upper platform, signs must be attached to actual walls, and openings on the first floor must not conflict with the room layout above.
- Asset structure: the deliverable is not just an image, but an editable project file with a reasonable object hierarchy, naming conventions, material grouping, and enough modularity for further editing.
- Style consistency: the entire scene must converge on a voxel language, with consistent color, lighting, and detail density rather than mixing photorealistic and cartoon elements.
- Interaction orchestration: turning a static scene into a web experience that can be rotated, annotated, and focused on is fundamentally frontend engineering.
More dimensions increase subjectivity. That is exactly why this type of evaluation is harder, and also why it conveys more information.
2. Test design: a deliberately bare-prompt experiment
To understand a model’s true level, the test conditions need to be strict. This experiment used three constraints:
- No mounted skills or plugins. If a ready-made modeling skill pack, asset-library retrieval, or rendering-script template is attached, the model degrades into an orchestrator and its real capabilities are masked by external tools.
- Bare prompts only. No step-by-step instructions, no reference images, no multi-turn corrections, and no iterative fixes. The result had to be produced in one pass.
- Only the theme and delivery format were described; interaction requirements were not. This intentional omission was used to observe whether the model would proactively fill in needs that were not mentioned.
The prompt used in the test was neutralized as follows:
Use a 3D modeling tool to create a voxel miniature scene themed around "a detective agency from a mystery-themed animated work." Draw inspiration from the street-side agency building in that work, make the agency itself the visual highlight, present the whole scene in a unified voxel-block language, and deliver an editable 3D project file plus rendered images.
The prompt contained only three pieces of information: theme, style language, and delivery format. Camera work, annotations, and web requirements were intentionally omitted. The only follow-up instruction was also a single sentence: open the project file in a browser page.
This approach makes “what the model added on its own” an observable variable.
3. Delivery results: structural completeness sets the passing line
The final deliverables were two rendered images, an editable 3D project file, and an interactive web page. Compared with the street-scene structure implied by the reference context:
- An outdoor staircase along the side of the building leading to the second floor: present.
- The second-floor agency room and façade: present.
- The street-facing coffee-shop storefront on the first floor: present.
- Two characters standing at the entrance: present.
Structural completeness passed the basic test. However, one element was missing: the most recognizable sign from the reference work did not appear in the model output. This leads to a key judgment: the absence of a key identifying element should not be averaged away or compensated for by other correct parts.
The reason is straightforward. The value of 3D generation depends on deliverability. If the model output is used as a base for campus guides, property sandboxes, or urban visualization, a missing sign means that the identity information for that location has no geometric carrier. Downstream annotation systems, retrieval systems, and guided narration will all lack an anchor. The cost of rework is often higher than generating the element correctly in the first place.
Another notable phenomenon was distortion caused by detail abstraction. The hairstyles of the two characters at the entrance drifted semantically after voxelization. Without scene annotation hints, it was difficult to determine character identity from shape alone. This is not necessarily an error. It is an inherent trade-off of voxel language under coarse quantization: when quantization becomes too coarse, recognizable information is often discarded first.
In evaluation, this type of distortion should be classified as acceptable loss caused by style constraints, and should be distinguished from complete omission of a key element. The former is a trade-off; the latter is an omission.
4. Interactive web page: value beyond the prompt
The most unexpected part was the web page. The prompt only said to open the project file in a browser, but the model filled in a full set of interaction features:
- Basic controls: mouse-drag rotation, wheel zoom, and automatic rotation for guided viewing.
- Scene annotations: clickable hotspot labels were attached to key objects to explain what each object was.
- View focusing: a sidebar listed several elements in the scene, and clicking one smoothly moved the camera to the corresponding position.
- Deliverable aggregation: the model download entry and the two rendered images were presented on the same page.
- First-visit guidance: after the first frame finished rendering, a drag prompt appeared to lower the usage barrier.
One easily overlooked insight here is that the annotation feature also exposed how well the model understood scene semantics. The names in the focus list were the model’s object-recognition results written directly into the interface. If the model misunderstood a character as another object during generation, users could spot it immediately. Annotation was therefore both a feature and a self-check.
{"id": "office-sign","label": "Detective agency sign","anchor": [12.4, 8.1, 0.0],"camera": { "position": [18.0, 6.5, 10.2], "target": [12.4, 8.1, 0.0] },"description": "Facade marker on the second floor; a main visual anchor of the scene"}
Representing annotations as this kind of “label + anchor + camera” data structure is a common practice in 3D visualization. Annotation data is decoupled from geometry data, so text and camera presets can be iterated independently without re-exporting the model.
Camera focusing works similarly. At its core, it is a camera preset plus transition interpolation:
// Click a focus item -> smoothly transition the camera to the preset positionfunction focusOn(annotation, controls, camera, duration = 800) {const from = { pos: camera.position.clone(), target: controls.target.clone() };const start = performance.now();function step(now) {const t = Math.min((now - from.start) / duration, 1);const k = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2; // easeInOutQuadcamera.position.lerpVectors(from.pos, annotation.camera.position, k);controls.target.lerpVectors(from.target, annotation.camera.target, k);controls.update();if (t < 1) requestAnimationFrame(step);}requestAnimationFrame(step);}
The rendered images were also worth noting. Lighting and post-processing were clean, the overall filter look was consistent, and there was no obvious aliasing or color banding. This kind of image-quality stability usually comes from a reasonable combination of common rendering configurations such as ambient occlusion, contact shadows, and tone mapping, rather than from a single special parameter.
5. From demo to production: what engineering work remains
A one-pass generation is a prototype; only when it can enter a project does it become an asset. Before reaching production usability, four things usually need to be added:
1. Asset hosting and delivery.
3D project files and rendered images can be large and should not be stuffed into the business backend and returned together with the page. The standard approach is to store them in object storage, let the frontend fetch them through time-limited access URLs, and use CDN edge caching to reduce initial-load waiting.
2. Lazy loading for large generated content.
Voxel scenes can grow quickly in face count and mesh count, and loading the whole package at once can easily stall the first frame. Feasible strategies include splitting by region, loading by distance-based levels, or merging and instancing voxel geometry to reduce draw calls.
3. Maintainable semantic annotations.
If scene annotations are hard-coded into frontend code, changing one piece of copy requires a new release. A more reasonable approach is to store annotations as independent configuration, such as the JSON structure shown above, read them at runtime, and allow operations teams to edit them independently.
4. Observability.
Loading time, rendering frame rate, and interaction errors on the web side need to be connected to logging services and monitoring alerts. Otherwise, online lag can only be discovered through user feedback.
These items are common combinations of general cloud capabilities and do not constitute a recommendation for any specific product. Actual choices should be evaluated based on the team’s existing technology stack and compliance requirements.
6. Writing better prompts: a checklist for higher first-pass success
Returning to the testing method itself, the lesson from the missing sign can be distilled into a practical checklist:
Explicitly list key identifying elements.
Instead of saying “faithfully reproduce the building,” name items one by one: the façade sign, the second-floor balcony, the outdoor staircase, the first-floor storefront, and the characters at the entrance.Lock the style granularity.
Specify requirements such as “uniform voxelization across the whole scene,” “minimum block edge length of X,” and “no photorealistic materials” to avoid style drift.Specify the delivery list.
State whether the editable project file, number of rendered views, and web page are required up front. Avoid adding them later as afterthoughts.Add camera intent.
Even if the task includes a web page, specifying the main viewpoint in advance can make the model’s default camera position closer to expectations.State exclusions clearly.
Any element that is allowed not to appear should be written explicitly. Otherwise, the model has a considerable chance of simply omitting it.
7. Evaluation dimensions and acceptance table
Turning subjective impressions into a reusable scoring sheet is one of the most valuable outputs of this type of evaluation:
| Dimension | Check | Judgment |
|---|---|---|
| Structural completeness | Whether key identifying elements are complete | Missing one item means no full score; no averaging |
| Spatial plausibility | Stair connectivity, floor alignment, no intersections | Minor intersections are allowed; logical contradictions are not |
| Style consistency | Voxel granularity, color palette, lighting consistency | Local photorealism counts as a deduction |
| Asset editability | Hierarchy naming, material grouping, modularity | A single monolithic mesh is considered unqualified |
| Render quality | Composition, shadows, color management | Obvious aliasing or color banding should be flagged |
| Interaction completeness | Rotation/zoom, annotation, focus, onboarding | Record items implemented even if not requested |
| Maintainability | Whether annotations are decoupled from configuration | Hard-coding in code requires later refactoring |
It is recommended to keep “Interaction completeness” as a separate column for self-initiated features. It does not represent the upper limit of model capability, but it directly reflects how high the usable starting point of the deliverable is. Building a full set of annotation and camera-focus interactions from scratch usually takes one to two days of frontend work.
8. Conclusion
The practical conclusion from this test is that the focus of 3D generation capability has shifted from “can it be drawn” to “can it be delivered as a complete result in one pass.”
Structural restoration met the requirements, render quality was usable, and the model proactively supplemented annotations and camera focusing. Overall, this was a clearly improved result. However, the missing sign is a reminder: under strongly constrained style languages such as voxels, the model’s default trade-off is to preserve the overall silhouette while sacrificing local recognizability. Production scenarios often require the opposite: the overall result may be rougher, but key anchors must exist.
The practical recommendation is therefore to write prompts like requirement documents and use acceptance tables like test cases. The value of evaluation is not to give a single model one overall score, but to accumulate a stable set of judgment criteria. Once the criteria are clear, horizontal comparisons across models and versions become meaningful, and the rework rate of generated results can be reduced.
