Testing LLM Creativity: Rendering Michelangelo's David in the Browser

1. Why Use “Reconstructing David” to Test a Large Model

When evaluating a model’s coding ability, closed tasks like “write a counter” or “build a login page” no longer offer much discrimination—there are plenty of ready-made templates that can hit the mark. What really separates models is open-ended creative work: clear goals, undefined paths, no standard answer, requiring the model to make a series of judgments on its own.

“Build an interactive Chinese-language website that clearly explains how Michelangelo’s David emerged from a block of stone” is exactly this kind of task. It tests four capabilities at once:

• Task understanding and autonomous decision-making: The narrative angle, visual style, interaction model, and technical approach are all left open; the model must weigh trade-offs itself.
• Multimodal resource integration: It needs to research background material, find legally usable 3D assets, write frontend code, and process 3D assets.
• End-to-end engineering capability: From assessing the environment and building a skeleton to debugging and delivery, it must produce a runnable, experienceable work—not a design document.
• Aesthetics and expression: The audience is expected to “develop a new understanding of carving and be willing to stop and observe.” This fundamentally tests the model’s narrative design and aesthetic judgment.

The value of such a task is that it cannot be satisfied by reciting templates; differences in results directly reflect a model’s true composite capability.

2. Task Design: Writing the Prompt as a “Curatorial Brief”

The effectiveness of open-ended tasks depends heavily on prompt design. The prompt used in this test can be abstracted into a four-part “brief”:

[Goal] Build an interactive Chinese-language website that helps ordinary
       viewers understand: how Michelangelo's David emerged from a block of stone.
[Effect] After viewing, the audience should not merely remember a few historical facts,
         but develop a new understanding of "the act of carving,"
         and be willing to stop and observe the work.
[Freedom] The narrative angle, visual style, interaction model, and technical approach
          are yours to decide. Use your judgment to find the expression
          that truly suits this theme.
[Process] First assess what the current environment can do, then proceed autonomously
          until you deliver a runnable, experienceable work.
          Do not stop at a plan or a mockup.

Four design points:

1. Write “effects,” not “feature lists.” Instead of specifying which buttons and sections the page should have, describe the feeling the audience should have, leaving the implementation space entirely to the model.
2. Explicitly declare freedom. Clearly stating “it’s your call” prevents the model from retreating to a conservative default template—most models tend to output safe, generic layouts when not explicitly authorized.
3. Process constraints prevent “stopping at the plan.” The line “assess the environment first—proceed autonomously—until runnable” is the key switch; otherwise the model can easily deliver a polished static mockup and call it done.
4. Front-load the delivery standard. “Runnable, experienceable” means the model must complete integration and self-testing itself, pushing acceptance pressure into the generation phase.

3. Technical Breakdown: The Three-Layer Structure of a 3D Narrative Website

3.1 Asset Layer: Openly Licensed Cultural Heritage 3D Scans

Both models ultimately chose the same publicly available 3D scan of David (STL format), sourced from a public cultural heritage digitization project under an open license such as “Attribution—ShareAlike” (CC BY-SA). This points to an important practical direction: digitized cultural heritage resources are a high-quality, compliant asset library for 3D creation, but licensing compliance must be handled:

• Attribution requirement: The page must credit the asset source and license type.
• ShareAlike: Derivative works in principle must be released under the same license.
• Commercial use assessment: Commercial scenarios require checking license terms clause by clause.

At the engineering level, raw scan assets usually cannot go live directly:

Raw STL (often millions of faces, geometry only, no materials)
  → Format conversion (glTF/GLB, adding materials and scene information)
  → Mesh simplification (low-poly for distant views + high-poly for close-ups, building LOD tiers)
  → Geometry compression + chunking
  → Object storage / CDN distribution, loaded on demand

3.2 Rendering Layer: Achieving a “Marble Feel” with WebGL

• Materials: Marble’s translucent, warm texture can be approximated with subsurface scattering techniques (translucency maps + ambient occlusion + moderate specular highlights).
• Lighting: A dark-room scene relies on a strong single-side light source to create volume, consistent with how sculptures are lit in real exhibitions.
• Performance: Mobile devices need degradation strategies—lower render resolution, disable real-time shadows, switch to pre-baked lighting—to keep frame rates acceptable on low-end devices.

3.3 Interaction Layer: Comparing Two Narrative Approaches

Given the same prompt and the same 3D asset, the two models produced radically different but equally valid approaches, representing two typical paths for 3D narrative.

Approach A: Process immersion. The site opens in a dark room with a block of marble standing in the center; holding a button drives the chisel, chunks of stone peel away, and David gradually emerges. The core metaphor lets the audience personally participate in “subtraction,” thereby understanding that carving is the art of removal. One particularly striking copy detail: the site offers an “undo” button, but clicking it displays—“Marble has no undo key.” Using a counterintuitive interaction to reinforce the theme is a classic narrative device.

// Approach A's interaction core (illustrative)
const state = { pressing: false, removed: 0 };
chiselBtn.addEventListener('pointerdown', () => state.pressing = true);
window.addEventListener('pointerup',   () => state.pressing = false);
function frame(dt) {
  if (state.pressing && state.removed < TOTAL_FRAGMENTS) {
    peelOffNextFragment();   // Peel off one piece of stone: fragment animation + particles
    state.removed++;
    updateReveal(state.removed / TOTAL_FRAGMENTS); // Control the statue's degree of revelation
  }
  renderer.render(scene, camera);
}

Approach B: Exhibition reading. A paper-toned background with chapter-based layout, like an interactive exhibition booklet; dragging a slider reduces the stone from a block layer by layer until David appears. The core metaphor translates “from stone to statue” into a quantifiable continuum, suited to close reading and revisiting, with higher information density.

Comparison conclusion: Approach A emphasizes the emotional impact of “doing,” while Approach B emphasizes the informational rhythm of “reading.” Both share the same asset, showing that once the asset layer and narrative layer are decoupled, the same material can support entirely different expressions—which is precisely the value of handing expression decisions to the model.

4. From Website to Video: A Multi-Stage Creation Pipeline

The second-stage task: based on the completed website and research, generate a 60–90 second Chinese vertical (9:16) short video that clearly conveys the essence of the website to a general audience and sparks interest in the David statue itself. The lessons from this stage can be summarized in four points:

1. Allow reuse and recombination. The prompt explicitly states “you may reuse assets, scenes, and code from the website, or reorganize the visuals,” giving the model room for secondary creation rather than starting from scratch.
2. Deliver complete specifications. Require a playable MP4 final cut, an editable project, and an asset source list. The editable project is key—it ensures humans can take over and modify, rather than being locked into a black-box final cut.
3. Write self-checks into the task. The line “actually review the final cut and fix obvious issues” pushes acceptance responsibility to the model rather than leaving it entirely to human fallback.
4. Distill into reusable skills. Package video production experience—camera language, pacing control, voiceover, subtitles—into reusable Skill modules callable across projects. Once experience is made explicit, it turns from “personal craft” into “engineering assets.”

5. Practical Findings and Engineering Recommendations

1. Flagship models “have ideas,” but you must do the cost math. The test clearly showed generational cost-performance differences: capable versions reason slowly, cost more per unit, and burn through long tasks quickly; newer versions with similar capability cost roughly half as much and run faster. A reasonable strategy is tiered model selection—use lightweight versions for exploration and iteration, flagship versions for key delivery milestones, and budget-manage quota consumption on long tasks.
2. Long tasks must be given “process anchors.” Open-ended tasks easily let the model stop at the planning stage; process instructions like “assess the environment first—proceed autonomously—deliver a runnable work” cannot be omitted.
3. Front-load asset compliance. Asset sources, attribution methods, and license types should be explicitly constrained in the task description to avoid rework after delivery.
4. Acceptance requires “hands-on experience.” Code that looks correct is not the same as an experience that is correct: interaction feel, load time, and mobile behavior all need to be verified by actually opening the site; videos must be watched in full and checked item by item.
5. Build an evaluation dimension checklist: narrative completeness, visual consistency, interaction feel, first-screen and loading performance, asset compliance, maintainability. Multi-dimensional scoring is more useful for cross-version comparison than “feels good.”

6. Conclusion

“Letting a model reconstruct David” does not really test whether the model can write 3D code, but whether it possesses judgment: judging what narrative suits this theme, what interaction can convey the core insight that “carving is subtraction,” and what assets are legally usable. When the prompt shifts from a feature list to a curatorial brief, the model’s output shifts from “a page that meets the checklist” to “a work with expression.” For developers, this methodology—“open task design—asset compliance—tiered rendering—multi-stage pipeline—tiered model selection”—can be transferred directly to any creative engineering project that involves AI.