Mug Story Building Story
Technical Demonstration · Blender MCP · 2025

Generating 3D Architecture
Through Conversation

What happens when you ask an AI to build, inspect, break, and repair a 14-story office building inside Blender — then replicate it into a four-building tech campus? This is that story.

14
Story Building
4
Building Campus
50+
MCP Tool Calls
3
Rebuild Cycles
01 — Scene Discovery

Before changing anything,
Claude learns to see

The first step wasn't generation — it was understanding. An existing low-poly building sat in the Blender scene. Claude's job was to figure out exactly what it was made of.

User Prompt"Connect to Blender and tell me what you see on the screen"

Claude's response began not with assumptions, but with systematic inspection. It captured a viewport screenshot, queried the scene graph, then ran Python to count every vertex, face, and material in the scene.

Claude takes its first screenshot — a low-poly building with teal glass windows and cream walls.

The hidden modifier stack

The breakthrough came when Claude discovered the building wasn't manually modeled. Beneath the surface lay an Array modifier (count: 9) duplicating one floor module vertically, and a Mirror modifier (X+Y) creating all four faces from a single quarter-mesh.

This wasn't trivia. It became the foundation for every expansion that followed.

MCP Calls 7 calls
# Key discovery call blender:execute_blender_code(""" for mod in obj.modifiers: print(f"{mod.type}: count={mod.count}") """) # → Array(count=9), Mirror(X+Y)

Python analysis reveals Array + Mirror modifiers — the procedural engine hidden inside the building.

Material & window mapping

Claude catalogued every material — cream Diffuse BSDF for walls, teal Glass BSDF for upper windows, amber Glass+Glossy for storefronts. It mapped glass face positions to identify exactly 3 window columns per quarter-mesh, with wall mullion strips between them.

The result: a complete architectural blueprint generated entirely from code inspection, not visual guessing.

16 materials catalogued, glass face positions mapped, floor-by-floor structure decoded.

Key Insight

Understanding the procedural system before touching geometry was the pivotal decision. Every successful edit that followed leveraged the modifier stack. The lesson: the first tool call should always be diagnostic, not generative.

02 — Vertical Expansion

Four new floors from
a single line of code

The Array modifier made vertical growth trivially elegant. Claude didn't model new geometry — it changed one number.

User Prompt"Firstly increase some floors"

Array count: 9 → 13. Four floors materialized instantly — complete with matching windows, mullions, and glass panes. The roof slab was repositioned with a simple Z-offset calculation. Total code: three lines.

MCP Calls 3 calls
blender:execute_blender_code(""" obj.modifiers['Array'].count = 13 roof.location.z += 4 * 0.327 """)

One parameter change. Four new floors. The modifier stack multiplies the result.

Verification from multiple angles

Claude didn't just trust the code. It rotated the viewport to front, side, and perspective views — verifying the window grid extended cleanly, the roof sat correctly, and proportions looked natural.

This inspect-after-every-change discipline became the session's defining pattern.

Multi-angle verification confirms the expansion is clean.

03 — Horizontal Expansion

Widening the building —
where complexity begins

Unlike vertical expansion, horizontal growth required direct mesh editing. No clean modifier lever existed. Claude had to work at the vertex level.

User Prompt"Increase the building horizontally — add more windows by expanding area"

Claude identified the repeating column module in the base mesh: a glass strip flanked by wall mullions, ~0.25 units wide. It duplicated this module twice, offset each copy, and extended the outer wall to match.

Vertex Y-positions reveal the repeating column pattern — glass, mullion, glass, mullion.

Y-axis: face duplication via bmesh

Using bmesh.ops.duplicate, Claude selected all faces in the column module range, duplicated them, and shifted copies by the column spacing. The Mirror modifier automatically doubled the additions on the other side.

MCP Calls 12 calls
for n in range(1, 3): geom = bmesh.ops.duplicate(bm, geom=module_faces) for v in geom['geom']: v.co.y -= 0.251 * n

Two new column modules appear on the front face. Mirror creates two more on the back.

X-axis: same technique, perpendicular

The identical approach was applied to the X-axis, widening the side faces. Then every dependent object — roof, foundation, ground floor windows — had to be proportionally rescaled to match the new footprint.

This worked. But it also introduced problems that wouldn't become visible until the next step.

X-axis columns were added, then the roof, base, and windows were rescaled to match the wider building.

04 — When Things Break

Three correction cycles —
and the decision to start over

No AI-generated model emerges perfect. The real test isn't whether errors occur — it's whether the system can see them, diagnose them, and fix them.

User Prompt"Once see all angles and tell me what mistakes are present"

Claude rotated through 8 viewport angles — front, back, left, right, top, and three corner perspectives. It found 10 distinct issues: misaligned roof, floating windows, double walls, triangular artifacts, and inconsistent window patterns.

Systematic rotation reveals cornice artifacts, misaligned elements, and inconsistent side-face patterns.

Fixes 1–3: Incremental patches

Roof alignment — recomputed from evaluated mesh, repositioned to (0,0). Emission artifacts — deleted faces by material index. Pediment duplicates — removed by Z-position and normal direction. Three clean wins.

Three quick fixes resolve alignment, emission artifacts, and pediment duplicates.

Fix 4: The one that failed

The Array modifier was repeating the opaque ground floor along with the window zone, creating alternating bands. Claude tried separating them — removing ground floor faces, adjusting the Array offset, rebuilding glass strips. Each fix introduced new problems. The mesh was now too tangled to patch.

The mesh after failed patches — glass strips with no wall surfaces. The Array has been corrupted beyond repair.

The rebuild decision

Claude recognized the inflection point: incremental fixes were compounding faster than they resolved. It deleted the entire broken mesh and rebuilt the window facade from scratch — 14 floors × 10 columns × 4 faces = 2,020 clean faces in a single parametric code call.

Sometimes starting over is faster than patching. An experienced 3D artist would have made the same call.

The rebuilt mesh: clean, uniform window grid on all four faces. Generated from nested loops, not mesh editing.

Rebuild code 1 call
for floor in range(14): for col in range(num_cols): add_face(bm, spandrel, wall_idx) add_face(bm, mullion_L, wall_idx) add_face(bm, mullion_R, wall_idx) add_face(bm, glass, glass_idx)

Ground floor & entrance fixes

The user spotted a double wall at ground level and undersized entrance doors. Claude identified the overlapping base object, scaled it to a thin plinth, rebuilt the ground floor with full-height storefront windows, and widened the entrance to a 3-bay glass opening.

Left: the double-wall problem the user flagged. Right: the fix — thin plinth, full-height storefronts, 3-bay door.

Key Insight

The most effective correction was not incremental patching but complete regeneration. The parametric approach — nested loops creating geometry — proved far more reliable than editing modifier-generated meshes. When corrections compound, rebuild.

05 — Tech Park Compound

From one building to
a full campus

The final challenge escalated dramatically. Having perfected a single building, the user asked Claude to think at campus scale.

User Prompt"Extend this to a tech park — replicate into four buildings facing each other, a fountain in the middle, a big fence, trees, and tech things in the compound"

This required a shift from mesh editing to scene composition. Claude duplicated buildings with rotation matrices, positioned them symmetrically, then layered in landscape and infrastructure elements.

Each building duplicated, rotated to face inward, and positioned 10 units from the courtyard center.

Central fountain & plaza

A circular stone basin, blue water surface, and tall spout column were generated from bmesh primitives. Surrounding the fountain, a paved circular plaza connects to four pathways — one leading to each building's entrance.

Stone basin, water surface, spout column, circular plaza, and four connecting pathways.

Perimeter fence with gates

An iron fence encircles the compound — posts every 1.5 units, two horizontal rails, and gate openings on all four sides marked by taller pillars. The gate gaps align with the pathways leading to the campus.

Dark iron fence with posts, rails, and gate openings aligned to the pathways.

28 trees, procedurally placed

Trees were generated from two primitives — a cone trunk and an icosphere crown — then positioned along pathways, at compound corners, and along the perimeter fence. Each tree is unique in height and crown radius.

Pathway trees, corner trees, perimeter trees — each with procedural trunk and crown geometry.

Tech infrastructure details

The finishing layer: a satellite dish on B1's roof, solar panels on B3, 8 lamp posts with emissive materials along pathways, wooden benches around the fountain, red entrance canopies on each building, and a tech park sign at the main gate.

Satellite dish and solar panels on rooftops, with lamp posts, benches, and canopies at ground level.

The completed campus

From a single prompt, Claude composed an entire tech park compound — four symmetric buildings, a central courtyard with fountain, perimeter security, landscaping, and functional infrastructure. ~15 MCP tool calls, one conversational turn.

The finished compound from above: four buildings, fountain, pathways, trees, fence, and tech infrastructure.

06 — Honest Assessment

What works, what struggles,
what breaks entirely

This demonstration is not a highlight reel. It's a truthful picture of AI-driven 3D — the capabilities, the failure modes, and the strategies that bridge them.

✓

Works reliably

Scene inspection. Modifier parameters. Procedural loops. Material assignment. Object transforms. Viewport screenshots.

⚠

Works with correction

Mesh editing. Modifier interactions. Scale management. Multi-object alignment. Succeeds in 1–3 fix cycles.

✗

Struggles significantly

Editing modifier-stack geometry. UV mapping. Exact proportions first-try. Topology-aware edits. Often need full rebuilds.

→

Best strategy

Procedural generation over editing. Simple modifiers. Rebuild when patches compound. Inspect after every change.

The workflow loop

Across every stage — discovery, expansion, correction, composition — the same pattern proved most effective:

Prompt → Generate → Screenshot → Diagnose → Fix → Screenshot → Repeat.

The quality of the final output depends less on first-try accuracy and more on the speed of this diagnostic loop.

Workflow montage frame

A montage of the iterative cycle: prompt, generate, inspect, diagnose, fix.

Conclusion

Claude can generate, inspect, and iteratively refine 3D architectural models through natural language. The path bends through failures and rebuilds. The modifier stack discovery in minute one shaped every decision. The rebuild decision in hour two saved the project. And the compound generation at the end proved that once a single-building workflow is validated, scaling is straightforward.