Testing a Multimodal LLM: Recreating Michelangelo’s David with AI

Why David Makes the Perfect Test Case

When evaluating what a multimodal large language model can actually generate, the choice of subject is itself part of the test. Michelangelo’s David is an ideal stress test for three reasons.

First, the anatomical complexity. The muscle structure, weight distribution, and proportions of the fingers and toes all have to be right. Any deviation immediately triggers an uncanny-valley reaction. The model either understands structure or it doesn’t — and David exposes that quickly.

Second, the material is simple but rich in detail. A marble statue may look like a single surface, but it actually contains subtle chisel marks, a matte finish, and translucent edge scattering under strong light. That puts serious pressure on material modeling.

Third, almost everyone knows what David looks like. No specialized background is needed to judge whether the output is good or bad, so evaluation is cheap.

It’s worth emphasizing that “recreation” and “generating a nice-looking image” are completely different tasks. Recreation requires the generated result to be compared against a known target. It naturally tests three capabilities: understanding a reference image, reasoning about structure, and preserving detail. That is why this experiment used a multimodal approach rather than a traditional single-modality image tool. A multimodal model lets you compare against the reference repeatedly in conversation and refine step by step. A single-modality image generator mostly leaves you blind-sampling and hoping for the best.

Technical Pipeline Overview

The full workflow has five stages, each feeding into the next:

Source preparation → Prompt construction → Multi-view image generation → 3D reconstruction → Evaluation and iteration

The output of each stage becomes the input of the next. Sloppiness at the front end gets amplified exponentially by the time it reaches the end. Here is each stage in detail.

Prompt Engineering: Translating Art Language into Model Language

This is the highest-leverage part of the entire workflow. Three lessons stood out.

Lesson 1: Break the prompt into structured parts. Don’t write an essay. Split the prompt into five dimensions: subject, viewpoint, material, lighting, and composition. Write each dimension as its own clause. A reusable template looks like this:

[Subject] Renaissance-style marble human statue, standing pose, weight resting on the right leg
[Viewpoint] Front view at eye level, camera positioned at chest height, full body in frame, centered composition
[Material] White marble, matte surface, subtle chisel marks and natural veining preserved
[Lighting] Natural light from upper left, soft shadow transitions, slight scattering at the edges
[Negative prompt] Cartoonish, real-skin texture, metallic reflection, fused fingers, distorted proportions

Lesson 2: Use negative prompts deliberately. The most common failure points for statue generation are the hands and face — fused fingers and stiff expressions. Writing these known issues explicitly into the negative prompt is far more efficient than repeatedly rerolling and hoping.

Lesson 3: Turn domain knowledge into reusable presets. Getting one good prompt is only the starting point. The real difference comes from packaging domain expertise — for example, “marble under strong light shows warm scattering at the lit edges” — into reusable style presets that can be mounted for similar tasks. During the test, I maintained several such preset templates. First-pass success was noticeably higher than starting from scratch each time. This confirms a common observation: the same model performs far better in the hands of someone who asks well-structured questions. The gap is usually not in the model, but in how well you manage your prompt assets.

Generation: Multi-View Consistency Is the Hardest Part

Generating a single image is easy. The hard part is making the front, side, and three-quarter views anatomically consistent with each other. Three practices worked well:

1. Lock the random seed and only modify the viewpoint description. This minimizes random drift.
2. Pick the best front-facing image as the anchor, then explicitly reference that anchor in prompts for other viewpoints, emphasizing consistency with the reference.
3. After batch generation, do a quick manual filter first. Discard results with obvious structural errors before any refinement, so you don’t waste compute on unusable images.

For resolution, follow a coarse-to-fine strategy: iterate quickly on composition and structure at medium resolution first, then switch to high resolution to enlarge details once everything checks out. Starting at maximum resolution and running everything blindly is the number one way to burn through your quota.

From 2D to 3D: Key Details for Reconstruction

Once you have acceptable multi-view images, the next step is 3D reconstruction. There are two routes depending on your needs. Single-image reconstruction is fast, but the back side is entirely filled in by the model, which makes it suitable for quick previews. Multi-view reconstruction yields higher quality, provided the views are strictly consistent — which is exactly where the anchor strategy from the previous section pays off.

After reconstruction, two things must be checked. First, normals. A statue is a closed solid, and broken surfaces or flipped normals will show up as black patches during rendering. Second, topology. High-curvature regions like the face and hands need enough mesh density to hold detail.

For textures, watch out for color temperature consistency. Differences in color temperature between viewpoint images will get baked directly into the texture map. It is better to apply color correction before reconstruction.

Quota Management: An Underrated Engineering Problem

The biggest pitfall in this experiment was not technical but resource-related. During the early exploration phase, I ran everything in high-precision mode while experimenting, and quota consumption far exceeded expectations. By the time I needed to produce a demo video of the result, the quota was nearly exhausted and I had to pause. Three rules emerged from that experience:

1. Tier your tasks. Exploratory work — trying compositions and styles — should always run in low-cost fast mode. Only switch to high precision after the direction is confirmed.
2. Estimate costs upfront. Before batch generation, run a small batch — say four images — to measure cost per image, then multiply by the planned volume before deciding. Avoid the “just run them all” reflex.
3. Reuse intermediate results. Save the compositions and seed values that work. Later iterations should build on existing outputs with localized changes, not start over from scratch.

If this kind of workflow is run regularly in a team environment, it makes sense to host the inference, storage, and logging on a cloud platform — such as Baidu AI Cloud’s general-purpose GPU compute, object storage, and monitoring services. This lets resources scale on demand instead of sitting idle, and it centralizes the generated assets for reuse across projects. Long term, that is the more economical path.

Quality Evaluation: Making “Likeness” Measurable

Artistic recreation can’t rely on intuition alone. The evaluation checklist used in this test had four items:

• Structural accuracy: Is the head-to-body ratio approximately 1:8? Does the weight-bearing posture match the original?
• Material fidelity: Does the matte marble texture and edge translucency hold up?
• Multi-view consistency: Are the facial features and muscle lines coherent across different viewpoints?
• Detail preservation: Are the curl groupings logical? Are all five fingers distinct?

Each item is scored, then a weighted total is calculated. The lowest-scoring dimension becomes the direction for prompt revision in the next iteration. This evaluation-driven loop converges much faster than repeatedly rerolling on gut feeling, and it makes the methodology easier to transfer to other projects.

Final Thoughts

Two takeaways stand out from this experiment. First, multimodal LLMs are already capable of handling structurally rigorous classical art recreation — but the ceiling is often not the model itself. It is the surrounding engineering: prompt assets, evaluation criteria, and resource management. Second, quota is a hard constraint. The more capable the model, the more tempting it is to experiment without limits. Task tiering and cost estimation must be standard parts of the workflow. With those disciplines in place, even an individual developer on a limited budget can bring a Renaissance masterpiece into their digital asset library at very low cost.