Building 3D Websites: What Five Hours of Tutorial

Andrew Wan's five-hour course on building a 3D café portfolio has accumulated views and GitHub stars since appearing on freeCodeCamp. The promise is straightforward: learn Blender modeling and Three.js integration by building something concrete. What interests me isn't whether the course delivers—by most accounts, it does—but what this format reveals about how we've come to learn complex technical skills.

I've been covering technology education long enough to remember when a five-hour tutorial would have been absurd. You learned Blender from a book. You learned JavaScript from documentation. The idea that someone would watch another person's screen for the length of a transatlantic flight was science fiction.

Now it's Tuesday.

The Topology of Learning

Wan spends considerable time on something called "emotional design breakdown." He analyzes reference images and assigns numerical scores to qualities like whimsy (70/100) and humor (80/100). "Once you have your proportional breakdown of what you feel and your emotions of each scene," he explains, "you can use that to shape the way that you want to create yours."

This is not how I learned to build things. But it's also not wrong.

The traditional path was technical fundamentals first, creative expression eventually. You mastered the tools, then figured out what to say with them. Wan reverses this: decide what you want to evoke, then learn enough technique to achieve it. It's the difference between learning music theory before touching an instrument versus learning three chords because you have a song in your head.

What surprises me is how effective this seems to be for a generation that has never known scarcity of information. When everything is documented, the constraint isn't access—it's motivation.

The AI Elephant

Wan uses Claude to generate Python scripts for Blender. He mentions it casually, the way you'd mention using a calculator. "Using AI (Claude) to generate python scripts/add-ons to add outlines," reads one timestamp. No fanfare. No moral panic.

This is where the generational divide becomes visible. I remember when StackOverflow was controversial—wasn't copying code cheating? Now we have tools that write the code, and the question has shifted from whether to use them to how to use them effectively.

The interesting bit: Wan isn't teaching AI prompting. He's teaching 3D web development. The AI is infrastructure, like npm or Git. When he needs a script to convert objects to emission materials, he generates it and moves on. The learning happens in knowing what to ask for, not how to implement it.

This bothers some people. It doesn't bother me. I watched the coding world survive the transition from assembly to high-level languages, from procedural to object-oriented, from waterfall to agile. Each time, someone insisted the new way would destroy understanding. Each time, understanding just moved up a level.

What Actually Gets Built

The final project is a scrollable 3D café scene with interactive elements, day/night modes, and mobile-responsive raycasting. It's playful—there's a capybara model. It's technically competent—the singleton architecture and WebGPU renderer aren't beginner mistakes. It's also completely unnecessary as a portfolio piece.

That's the point.

Wan explicitly structures the course around building something that demonstrates craft, not utility. "By the end, you'll know how to model everything," he says early on. "Everything else is just a combination of the same techniques."

The café isn't the lesson. The café is proof you learned the lesson. This distinction matters in a field where demonstrated ability increasingly trumps credentials. You can't fake having built something interactive that runs in a browser. You can absolutely fake understanding by regurgitating documentation.

The Subdivision Surface

There's a technical concept called subdivision surface modeling that Wan introduces early. You start with blocky shapes, then add a modifier that smooths everything into organic curves. "You add a subdivision surface modifier that will basically cut up your mesh into a bunch of other squares," he explains. "Because you have so much more topology to work from, it gives it a sort of bendy and wavy shape."

It's a metaphor that extends beyond Blender. Modern learning operates on similar principles. You start with rough understanding—this button does that thing—and progressively add detail until something smooth emerges. The five-hour format isn't about comprehensive knowledge. It's about sufficient topology.

Wan explicitly acknowledges this. When covering certain advanced topics, he labels them "(Optional)" in the timeline. Infinite looping, light baking, scene switching with render targets—all optional. The core path is clearly marked. The rest is there for people who need it or want it.

This is honest in a way that traditional curricula often aren't. Universities pretend everything matters equally. YouTube acknowledges that most people will use 20% of what's taught and won't know which 20% until later.

The Compression Question

One chapter addresses "compression and optimization." Four minutes. This is probably inadequate for production work—professional 3D web developers spend considerable time on performance. But it's enough to know the concern exists and where to look for solutions.

This is where tutorial learning shows its limitations. Wan can demonstrate that optimization matters. He can show basic techniques. He cannot—in this format—convey the experience of debugging a model that tanks frame rates on mid-range devices, or the judgment to know when visual fidelity is worth the performance cost.

That knowledge comes from building things that fail. The tutorial gets you to the starting line of failure. That's not a criticism. That's the only thing a tutorial can realistically do.

What We Don't See

The chapter list includes a correction: "Remove the extra init in the constructor of Renderer.js." Someone caught a bug after publication. The fix is noted, but the original error presumably remains in the video.

This is increasingly common in video tutorials—they can't be edited like text. Once published, they're artifacts. Errata accumulate in description boxes and comment threads. The learning experience becomes collaborative by necessity, not design.

It works, mostly. But it also means that watching a tutorial requires reading around it—checking comments for corrections, verifying techniques haven't been superseded, translating deprecated syntax. The video is the core, but the learning happens in the margins.

The Actual Question

Can you learn 3D web development from a five-hour video? Yes, in the sense that you can build something functional by the end. No, in the sense that you'll understand every decision or recognize when to break the patterns.

But that framing assumes learning is binary. It's not. Wan's course does what it promises: it provides a worked example of creating an interactive 3D web project from concept to deployment. Whether that's learning or just following along depends entirely on what happens after the video ends.

The students who succeed will be the ones who build something else next—who take the café template and make a restaurant, or a storefront, or something that has nothing to do with food service. They'll hit problems Wan didn't cover. They'll solve them or give up.

That's always been true. The five-hour format just makes it more visible.

—Bob Reynolds