A complete, scroll-driven 3D landing page can now come out of Claude Code without anyone opening Blender or typing a line of Three.js, a JavaScript library for 3D graphics in the browser. The project described here, a fictional architecture studio site called Tracewood, took about 10 human prompts over two days. Claude Opus 5.5 did the rest: roughly 1,500 autonomous tool calls and around 10 hours of computation. The interesting part is not the single prompt that started it, but how the work was split up. The human curated references and set the mood. The model wrote the plan. And a separate, memory-free judge graded every render until the site crossed a target score of 8 out of 10.

References first, prompt second

The guiding rule of this build is that a lazy one-line prompt produces generic output, and that good references do most of the aesthetic work before generation starts. The reference source was Mobbin, a library of more than 500,000 screens and user flows captured from real shipped web and iOS products. Shipped software is treated as better reference material than portfolio mockups because it has already survived real usability demands.

Mobbin exposes a Model Context Protocol (MCP) server. MCP is Anthropic's open standard that lets an AI tool call outside services directly. Wiring it into Claude Code takes about a minute:

  1. In the Claude desktop app, select Claude Code at the top left and open the Customize menu.
  2. Go to the Connectors tab, find Mobbin, and add it.
  3. Authenticate with a Mobbin account.

Once connected, Claude Code can run queries such as search_screens, search_flows and search_sections. One practical detail matters here: append "with screenshots" to the request so the model actually looks at the images rather than receiving a list of links. For the build itself, the model was set to Claude Opus 5.5 with the reasoning effort slider turned all the way up to High.

Searching Mobbin's Sites catalog for "3D website" returned more than 1,200 sections, many with interactive video recordings. That matters because motion and camera transitions are the core of 3D web design, and a static screenshot cannot show them. Two studios anchored the concept. Basement Studio's site renders its own office as a monochrome wireframe loft with a mezzanine, a staircase and floating pixel trails. Poly's site shows a warm wooden desk in soft daylight, covered with prints, magazines and film strips. The point was not to copy either one. From the first came the line-drawn environment and the idea of moving through a single room; from the second came the warm materials, sunlight and the layout of physical prints on a work surface. Fused together, they became Tracewood: a room that starts as a line drawing and resolves into a fully sunlit interior.

A prompt with no technical instructions

The opening prompt to Claude Code was deliberately short and non-technical: build an immersive 3D-world landing page in the Basement Studio and Poly style, where the whole page is one scene. It mentioned no frameworks, no WebGL, no shaders and no Three.js. The reasoning is that early prompts should describe atmosphere, user experience and camera behavior, and leave implementation choices to the model.

Opus 5.5 responded with a full plan. It framed Tracewood as an adaptive reuse of an old print works in Lisbon and organized the site into five narrative chapters, Studio, Process, Work, Services and Contact, each mapped to a camera stop inside the same room. Scrolling does not move document content; it moves the camera along a defined 3D path.

A second plain-language prompt asked for the Services section to be interactive, so that clicking a paper reveals more information. The result is a corkboard where pinned sheets swing off their pins into an expanded overlay listing scope, deliverables and project links. The mindset throughout is to treat the agent like an employee handed a complex assignment: give it direction, then give it enough time to iterate rather than expecting a finished product from a five-minute run.

Sunlit wooden desk with blank paper layouts, a flat cutout plant and striped blind shadows, corkboard behind

▲ Mixed media: code-drawn prints and 2D cutout plants

Not everything should be 3D geometry

One of the most transferable lessons is that a 3D scene should mix rendering techniques, choosing the right medium for each element rather than modeling everything as polygons.

Element Technique Reason
Room architecture and main furniture Full 3D geometry The camera moves around them and lighting must react
Wireframe lines Procedural code generated from edge geometry They sweep open on scroll to reveal solid surfaces
Paper prints on the desk Drawn programmatically in code Type stays crisp at any zoom level
Plants 2D billboard cutouts from high-resolution photos Modeled foliage tends to look stiff and artificial in WebGL
Sunlight and blind shadows Baked into surface textures Real-time web lights failed to reach the desired realism

Even with these choices, the first compiled version of the site scored only 4.6 out of 10 on the evaluation rubric. The lighting was flat, window glass carried a green haze, and the space felt empty. That is where the judge loop came in.

Two monitors showing a 3D room render and its polished target, with a four-arrow loop diagram and scorecard between

▲ Render versus target in the judge loop

The judge loop: Change, Capture, Compare, Judge

Telling an agent to "make it better" produces aimless guessing. The alternative used here, an open-source skill called dream-loop, replaces vague instructions with an explicit target and an impartial critic. It begins by screenshotting the current camera angle and handing that image to an image generation model, which produces a polished target render of the exact same viewpoint. Each round then runs four steps:

  1. Change: modify the scene code.
  2. Capture: render the live page from the same camera.
  3. Compare: place the render side by side with the target.
  4. Judge: have a fresh subagent grade the result.

The judge has no memory of earlier rounds. It scores the render on a 10-point scale and writes a markdown critique that spells out gaps in lighting, materials and composition. The score progression for the opening view shows where the gains actually came from:

Round Score What changed
1 4.6 Initial build, flat lighting
2 to 9 5.3 to 6.85 Lighting, ambient occlusion, light probes, bloom, baked textures
10 7.85 Plant cutouts matched to the target image
11 8.05 Passed the 8.0 threshold

The notable pattern is that visual fidelity came mostly from lighting, shadows and texture baking, not from more complex geometry.

The dream-loop cycle that repeats until the render passes the target score No Yes Screenshot currentcamera angle Image generation modelproduces target render Change: modify scene code Capture: render live pagefrom the same camera Compare: place renderside by side with target Judge: fresh subagentgrades on 10-point scale Score above 8.0? Passed the 8.0 threshold
▲ The dream-loop cycle that repeats until the render passes the target score

Setting up dream-loop

The skill is MIT-licensed and hosted on GitHub. Installation takes about a minute by any of three routes: an npx skills add command, cloning the repository into the ~/.claude/skills directory, or pasting the GitHub URL into Claude Code. The agent needs vision input, access to an image generation model, and optionally subagent orchestration. Because Claude does not generate images natively, an external image service called Aura supplied the target renders here; Grok or Gemini can fill the same role. Blender is optional and only needed for custom modeling scripts or MCP integrations.

The loop starts by mentioning "dream loop" in a prompt or typing the /dream-loop slash command. It creates a local .dream-loop/ folder holding target.png, side-by-side comparisons and a verdict markdown file for each round. The single most important operational rule: set a strict time limit or score threshold up front, because an autonomous loop with no stopping point can consume tokens quickly.

Furnishing the lounge and fixing what broke

The opening view reached its target, but the mezzanine lounge at the end of the scroll felt bare. A plain-language request for a modern, high-end interior with bespoke decorations sent Opus 5.5 back into the loop on that camera angle. The new target featured a curved bouclé sofa, cognac leather chairs, a travertine table, a wool rug and an illuminated drafting desk. Individual props improved round by round; the sofa started as what the critique called a flat sausage and became a soft rolled tube with thick sculpted arms. The arc lamp was reoriented so its neck curves across the view instead of receding from the camera. To keep framerates high in the dusk scene, the model limited itself to three active dynamic lights. The lounge score climbed from 4.90 to 6.25, and the workstation desk view rose from 6.40 to 7.60 with accurate paper shadows.

Three bugs along the way are worth remembering:

  • Light probe contamination: adding dark lounge furniture turned the daytime walls and ceiling grey, because the global light probe captured the furniture across the whole loft. The fix was to hide the lounge pieces while capturing the daytime probe.
  • Blocked sunlight: the window blinds occluded all direct light until their slats were tilted parallel to the incoming sun rays rather than perpendicular.
  • A swallowed line: an inline comment on one line of Three.js code accidentally commented out the solids.add(g) call, making every tabletop prop disappear.

Performance is handled by benchmarking frame time in real time and lowering the internal render resolution when framerates drop. On the Mac used for testing, furnished rooms ran at 55 to 80 frames per second and wireframe views above 100. For mobile, the scene uses narrower camera framing and a bottom sheet that slides up to show project details.

What it cost, and where humans still matter

Claude Opus 5.5 is priced at $4 per million input tokens and $20 per million output tokens, roughly 40 percent less than Opus 5 on typical workloads. Against that, the human side of the Tracewood build was about 10 prompts across two days, while the model executed around 1,500 tool calls over roughly 10 hours. These are the figures from this one project, not a general expectation.

The division of labor that emerges is fairly clear. The model dominates speed, stamina and raw execution cost. The human still owns reference curation, mood, and the decision of when something is good enough. On that basis, AI does not appear ready to replace 3D web designers outright, since it lacks independent taste, emotional intent and stopping judgment. At the same time, bespoke 3D experiences are the kind of work high-end clients pay $10,000 to $30,000 for, and those clients judge the final experience, not whether a person or a machine wrote the WebGL.

What to take from this

The technical breakthrough here is less about Claude Opus 5.5 writing Three.js and more about the structure around it: strong references, a prompt that describes feeling rather than frameworks, a plan the model writes itself, and a closed loop where a memory-free judge compares each render to a concrete target. If you want to try the same approach, connect a reference source like Mobbin through MCP and ask for screenshots, keep early prompts conceptual, mix geometry with cutouts and baked textures instead of modeling everything, and run the judge loop only with a round budget or score cutoff in place. Then plan to spend your own time where the model is weakest: deciding what the thing should feel like, and deciding when it is done.