Your First 3D Game Assets with Claude and Blender

Three simple 3D assets for a game, built with Blender and an AI agent, then checked by numbers instead of by trust. This is the whole assignment in one film: learn Blender's window first, write the brief before you build, connect Claude to Blender, build a crate, a lantern, and a coin one at a time, export them as .glb, import them into Godot, and let a headless check say what it can and cannot prove. Made for students in CSYE 7270, Virtual Environments and Real-Time 3D, and for anyone directing an AI agent in Blender.

Six terms: an asset is a 3D model, image, or sound a game uses; MCP, the Model Context Protocol, is a standard letting Claude drive Blender directly.

The job: three simple assets, built from Blender's basic shapes only, under a budget of six basic shapes and 500 triangles total. Default Blender geometry blows that budget fast, so segment and ring counts need lowering deliberately. From the second assignment on, one game grows in one repository, each assignment adding a layer.

Tools: Claude Code via university access, free Blender, and the free Blender MCP add-on. One provenance rule: geometry is built by hand, with Claude, in Blender, not downloaded or AI-generated from an external service. Before starting, the course's AI policy video explains what must be disclosed about AI's role.

Before touching Claude: open Blender and just look, then name six interface parts in your own words, with a screenshot as evidence. Then commit a brief before building anything: each asset's name, role, and location in the game; its size in metres, justified against something concrete; its origin point; its recognizable shape and material colors; its triangle budget; and at least three predicted failures, each with the check that would catch it.

Connecting Claude to Blender: an add-on opens a local socket, with a small server launched via a one-line installer. Safety note: this runs Claude-written Python inside Blender with no guard by default, so keep the port on localhost, save work first, disable the add-on when not in use, and never open untrusted Blender files while the server runs. In this recorded run, the Blender MCP route itself was documented but not completed by the course; assets were built via the script-route fallback instead (Blender 5.1.2, 60/202/180 triangles against the 500 budget).

Build one asset at a time: Claude proposes a plan, calls get_scene_info, executes one Blender-code call per object, and reports dimensions after each step; human review in the viewport after every step is required, since Claude can't judge whether it looks right. At least one hand edit per session is required, documented. Export each asset as .glb with +Y Up, import into Godot 4.7.2, and verify with a headless script comparing node scale, position, and triangle count against the brief.

Your Turn: Paste into Claude: "I'm building a game that needs a simple 3D wooden crate. Help me write a brief for it: a size in metres, justified against my player's height, an origin at the centre of its base, a triangle budget of 500 or less, and three predicted failures, each with the check that would catch it. Then write a short Blender Python script that builds the crate from basic shapes with no window, applies its transforms, and prints its dimensions and triangle count. Finally, tell me what that printout cannot prove." Then check two things yourself: is the size justified against something in your game, not just made up, and do the printed dimensions match the brief with transforms applied?

Sources: Assignment 3 of CSYE 7270 (Nik Bear Brown, Northeastern University); MCP for Blender project README, versions 2.1.1 and 2.1.9, github.com/ahujasid/mcp-for-blender; Blender 5.1.2 and Godot 4.7.2, run locally; the course's AI policy video, youtu.be/8Ut0Cdl6vMw.

0:00 The idea: you direct the AI, you measure it, you judge it 0:16 Terms in this lecture 0:39 I. Three simple assets: shapes, a 500-triangle budget, a growing game 3:05 II. Learn the window first 3:55 III. Write the brief before you build 5:15 IV. Connect Claude to Blender 7:31 V. Build the assets 8:55 VI. Export, import, check 10:43 VII. Ship it, and how it's graded 12:21 Recap 12:43 Your turn

Course: CSYE 7270, Virtual Environments and Real-Time 3D, Northeastern University Credit line: @NikBearBrown Hashtags

SEO Keyword Tags

Blender MCP Claude, CSYE 7270, Claude Blender tutorial, 3D game assets Blender, Blender to Godot workflow, glTF export Blender, Blender Python scripting AI, AI agent 3D modeling, Model Context Protocol Blender, Blender triangle budget, Godot 4.7 import assets, game dev AI assignment, Blender MCP add-on setup, headless Blender script check, Northeastern game development course

What this video covers

• 0:00 — Assignment overview
• 0:40 — Project requirements
• 1:11 — Asset design constraints
• 1:57 — Game integration
• 2:25 — Tooling and policy
• 3:05 — Learning the interface
• 3:55 — Preparing the project brief
• 5:16 — Connecting Claude to Blender
• 7:31 — Building and editing assets
• 8:55 — Exporting and importing
• 9:35 — Verification and quality control
• 10:43 — Submission and grading
• 12:00 — Summary and final tips
• 12:43 — Getting started with Claude

Transcript

A lightly formatted transcript of the video, with timestamps so you can jump to any section on YouTube.

Assignment overview

[0:00] Hello, this is Liam in forbear with the third assignment for CSYE7270 virtual environments and real-time 3D. The shortcut is to let an AI make your 3D models and accept whatever comes back. This assignment is the opposite. You direct it, you measure it, and you judge it. Six terms. An asset is a 3D model, image, or sound a game uses. MCP, the model context protocol, is a standard that lets an AI call another program's tools. A GB is a single file that holds a 3D model. The origin is the point a 3D model is placed and rotated from. A triangle budget is the most triangles a 3D model may use. And last, a bounding box is the smallest upright box around a shape. Here is the job.

Project requirements

[0:40] Make three simple 3D assets for your own game. A crate, a lantern, a coin, whatever your game could use. Then show that they arrived in the game engine the way you meant. You don't make them alone. Claude drives Blender, the free 3D modeling program, through a standard called MCP. and you stay in the loop because at least one edit has to be yours made by hand. Pick things you actually want in your game. A prop like a crate or a lantern, a piece of the environment, a platform, a tree, a rock, or something the player collects like a coin or a gem. Simple has a precise

Asset design constraints

[1:12] Meaning. Build each asset from Blender's basic shapes: cube, cylinder, cone, sphere, plane. Move them, scale them, combine them, give them a flat color. No sculpting, no painted textures, no rigging, no animation. And there's a budget no more than six basic shapes and no more than 500 triangles. A triangle is the flat three-sided face every surface is cut into. Those limits keep everyone's work comparable. They aren't the engines. Watch the trap we counted in Blender 5.1. A cube is 12 triangles. A default cylinder is 124. A default sphere is 960. Nearly twice the whole budget. So ask Claude to lower the segment counts. The same sphere cut into 12 segments and six rings is 120 triangles. Now the game from the second

Game integration

[1:58] Assignment on you build one game in one repository. Each assignment adds a layer and you hand it in as a git tag. This one's tag is a three. Your game doesn't have to be 3D. If it's 2D, you still make three assets that suit it and you add a small 3D scene to your repository. A floor, one light, a camera, and your three assets side by side at game scale. Later assignments reuse that scene, so you don't need to connect it to your 2D game yet. The tools claude code through

Tooling and policy

[2:27] Your university access, Blender, which is free, and the Blender MCP add-on, also free. Nothing paid is needed, and nothing paid earns credit. One rule on improvements, you build the geometry yourself with Claude in Blender. A downloaded 3D model or an AI generated mesh doesn't count. The add-on can also fetch 3D models from other sites and ask AI services to generate 3D models. Leave every one of those switched off. They call remote services and some may cost money. Before you start, watch the courses AI policy video. Whatever AI does for you, say what it did and be able to explain every part of what you hand in. Before you write a single

Learning the interface

[3:06] Prediction, open Blender and just look, orbit, pan, and zoom the 3D viewport. Spend a short session with no prompting at all. Then in your own words, name six parts of the window. First, the 3D viewport, the big view where your 3D model lives. The toolbar holds the tools you click to move, rotate, and scale things. The outliner lists every object in the scene as a tree. The properties editor holds the settings of whatever is selected. Press N, and the sidebar opens. It shows the active objects location, rotation, scale, and dimensions. And in the viewports header, the mode selector switches between object mode where you work on whole objects and edit mode where you reach into the points and faces of one. Add one screenshot of your own session with an object selected to a notes file. That's your evidence that you looked.

Preparing the project brief

[3:55] Now the brief. Before you ask Claude to build anything, commit a file that says what you expect. Keep the original. Add revisions. Don't rewrite it to make every prediction look right. For each asset, its name, what it is in your game, and where it appears, its size in meters, width, depth, height. Justify it against something in your game, like the player's height, a tile, or a door. In Blender, one unit is 1 meter, and God dot's 3D units are meters, too. So, if you keep it that way, nothing needs converting. Its origin, the point the 3D model is placed and rotated from. For a prop that stands on the floor, the center of the underside is usual. Build around Blender's world origin, the point where the three axes meet with

The base on the floor there. Put the origin in the middle instead, and the 3D model won't sit on the floor. At floor level, it sinks half its height. Lift it by a guess and it floats. Lift it by exactly half its height, and it sits, but only because you moved it. So, a check has to look at the origin itself, not just the gap to the floor. its look, the shape that makes it recognizable, and its material colors, its budget, your triangle number at or under 500, and why. Finally, at least three predicted failures each with the check that would catch it. It arrives lying on its side. It's wrong by a factor of 10. The server won't connect. A color doesn't survive the export. Now, connect Claude to

Connecting Claude to Blender

[5:17] Blender. An add-on inside a running Blender opens a local socket, and a small server launched by Claude code, relays Claude's tool calls into the open window. That's the MCP route. Be clear about what's known. The course hasn't run this route. These steps come from the project's own readme as recorded on the 27th of September, and the project changes fast. By the 6th of October, the readme led with a oneline installer. It finds the MCP clients on your machine and lets you pick which to set up, not only clawed code. The assignment says use the manual steps. Step one, on a Mac, install UV with Homebrew. The readme warns against installing it with pip. Step two, register the server with claude code. The readme's own line is shorter. This version adds

One setting which turns off the server's anonymous usage record. Step three, install the add-on. Then in Blender, open edit preferences, add-ons, and enable interface MCP for Blender. The add-on starts its server when Blender opens. To check, press N and open the MCP for Blender tab. Every service and download checkbox stays off. Then start a fresh clawed code session, so it sees the server. Now, the safety note plainly, by default, this runs Python that Claude writes inside your Blender with no guard. The readme says the socket has no authentication or encryption. Anyone who can reach that port can run Python inside Blender. So, keep the port on local host. Save your work first and turn the add-on off in preferences when you're not using it because the socket opens whenever Blender

Starts with it enabled. Last, don't open Blender files from people you don't trust while the server is running. If it doesn't connect, that's data. Give it about 2 hours and write down each step in its exact error. After that, you may switch to the script route. Claude writes a Blender script and you run Blender with no window. Here is that command. -B runs Blender in the background. Factory startup skips your own settings. Python runs the script. And Python exit code one makes a crashing script fail loudly. Without it, Blender exits with zero, even when the script raises an error. An honest specific account of a failed attempt with a working script fallback earns up to six of the eight MCP points, not all eight. Now build one asset at a

Building and editing assets

[7:32] Time. Ask Claude for a plan first. The prompt names the workflow, points at your brief, and gives one task this asset exactly as the brief says. The prompt has Claude start by calling get scene info and say what's already in the scene. Then propose steps it doesn't build yet. After you approve one execute Blender code, call per object. After each, it has clawed report the object's location, size, rotation, and scale. Apply rotation and scale before finishing and show you the result. The prompt names the 3D model downloads and the AI generation tools and forbids them. And it ends with a request, say what you could not verify. Tool names drift. The version the course recorded had get object info, get viewport screenshot,

And export scene. By the 6th of October, version 2.1.9 had removed all three and added a tool called look. Use whatever your install has. Your job in the loop. Look at it yourself in the viewport after every step. Claude can't tell you whether it looks right. Make at least one change by hand. Move apart, scale it, or change a color. Write down what you changed and what it taught you about the interface. Save the code. Copy every execute Blender code body into a script, one per asset. Otherwise, Git won't show how the asset was built. And save the blend source of each asset. Blender keeps the previous saved version beside it named.b blend one. Don't commit that. Export each asset as a GB

Exporting and importing

[8:57] Binary gltf a format god dot reads directly in Blender's exporter the plus yup option should be on it is by default that's because blender z-axis points up and in gltf and god do y does the exporter turns the world on the way out the newer MCP version has no export tool so use blender's own file export glTF2.0 to or have Claude run the exporter through execute Blender code and save that code too. Put the three files inside your God project and import. Then build the small scene, a floor, a light, a camera, and the three assets side by side at game scale. Now check by number.

Verification and quality control

[9:36] Ask Claude Code to write a short headless script, one that runs with no window. It loads each asset and prints its bounding box size, its node scale, and the axis it stands along. Compare those numbers with your brief and with the dimensions in Blender's sidebar. The node scale should be one, one, one. Each asset should stand upright. Place each asset on the floor without moving it. Does it sit, sink, or float? That test your origin. Move the node to compensate, and you've hidden the problem. Check the triangle count, too. Rightclick Blender status bar, and enable scene statistics. Is each asset within your budget? Read the check Claude wrote. A check can prove less than it claims. In one recorded case, an agent's floor check stopped on the object's own collider and proved nothing about the floor. Then the part no number covers. Walk the camera around each asset, including from behind and from below. Do the shapes read as what they are at game size. Are faces missing or colors wrong? And make at least one revision from something you saw, a size you corrected, an origin you moved, a part you rebuilt. Write the cycle down. Don't delete a failing assertion to turn a report green. Then one film short and

Submission and grading

[10:44] Plain is fine. It names your game and your three assets and shows your real Blender session with at least one prompt in your own hand edit. It shows the assets in the running god dot scene with the headless numbers beside your brief. It says what you checked what's uncertain what cla got wrong and who did what human and AI show screenshots or recordings you made yourself labeled as such. A reconstruction is labeled a reconstruction. Post the source to GitHub, the project, the 3GB files, the blend sources, the scripts, and your notes. Keep large media out. Tag the submitted. Commit a three. Push the tag and don't move it after you submit. Then verify from a clean clone of the tag.

Import once. Run your check. Open the scene. A working folder on your own machine isn't proof that everything was posted. Hand in a source zip and a submission note. the three assets, which route you used, your hand edit, the checks you ran, and the film link with its checksum. Grading 60 points for the work in its explanation, 10 for your honest log, 10 for matching versions on GitHub and Canvas, and 20 relative to the class. Meeting the criteria can earn the other 80. It doesn't guarantee the 20. Of the 60, 10 for the brief, 14 for the process, 18 for the three assets, 10 for the god checks, and eight for the film. Late work loses 10% a day and you

Summary and final tips

[12:02] Must be able to explain it. Be ready to open an asset in Blender and show where its size, origin, and applied transforms are and which part you edited by hand. One last point, a passing check shows your assets arrived at the size, orientation, and scale you measured. It doesn't show they look right in your game. That judgment is yours. Let's recap with Claude. Three simple assets, basic shapes under 500 triangles. Learn Blender's window first and name it six parts yourself. Write the brief before you build. Size, origin, budget, predicted failures. Connect with the manual steps. Mind the open socket and fall back after two hours. Direct Claude one asset at a time. Look yourself and make one edit by hand. Check the numbers in god dot. Judge the look with your own eyes. Then ship. Your turn. Paste this

Getting started with Claude

[12:44] Into Claude. I'm building a game that needs a simple 3D wooden crate. Help me write a brief for it. A size in meters justified against my player's height and origin at the center of its base. A triangle budget of 500 or less. and three predicted failures each with a check that would catch it. Then write a short Blender Python script that builds the crate from basic shapes with no window applies its transforms and prints its dimensions and triangle count. Finally, tell me what that printout cannot prove. Then check two things yourself. Is the size justified against something in your game and not just made up? And do the dimensions the script prints match the brief with transforms applied? Your first 3D game assets with Claude and Blender at Nick Bear Brown.