Fabricating assets skill for AI agents

​

When your agent uses it

• Writing a Blender Python (bpy) script for summer_fabricate_3d and deciding whether fabrication, generation, or the free library is the right route for an asset
• A parametric hard-surface set with exact dimensions, booleans, bevels, and shared materials that must stay consistent across many pieces
• VFX meshes — shatter fragments, curve sweeps, trails, LOD chains — or decimating, UV-unwrapping, and baking a generated model before it goes into the scene
• A fabrication failed (blender_not_found, script_error, export_empty, import_failed, busy, timeout) and the result needs to be read correctly

​

Install

npx -y summer-engine@latest skills install fabricating-assets --agent claude-code

​

The skill

​

Overview

1. It is optional and detect-never-bundle. Summer does not ship, download, or install Blender. If the machine has none, the result is a structured blender_not_found with the fix, and the decision to install belongs to the user.
2. It is blind until import. There is no viewport while the script runs. Perception comes back only through the result (objects, dimensions, warnings, skipped) and then through the normal scene loop (summer_snapshot_diff + summer_screenshot).
3. One fabrication at a time per editor. A second call while one is in flight fails with busy. Wait for the result; never fire in parallel.

​

Route first — fabricate, generate, or import?

​

Prerequisite — the user’s Blender

1. blender_path passed in the call (only when the user named a path — never guess one);
2. the SUMMER_BLENDER_BIN environment variable of the editor process;
3. Editor Settings → FileSystem → Import → Blender → Blender Path (filesystem/import/blender/blender_path, the same setting .blend import uses);
4. PATH, the platform’s well-known install locations, and ~/.summer/tools/blender-<version>/.

​

The script contract

• Do not export, do not save, do not quit. bpy.ops.export_scene.gltf, bpy.ops.wm.save_mainfile, bpy.ops.wm.quit_blender in your script break the contract and the run.
• What exports: MESH, CURVE, SURFACE, META, FONT objects become meshes; EMPTY and ARMATURE keep hierarchy and skins; cameras, lights, probes and speakers are dropped.
• Hidden means helper. An object hidden in the viewport or disabled for render is treated as a boolean cutter or guide: it is not exported and is listed in skipped. Use this deliberately for cutters; check skipped when a piece is missing.
• Modifiers are applied at export (export_apply), including Geometry Nodes — the scene stays non-destructive, so do not modifier_apply by hand unless you need the result for a later step (a boolean whose output feeds a second boolean, for instance). Consequence: shape keys are dropped when modifiers exist; a warning says so.
• Only a Principled BSDF surface survives glTF. Any other shader (Emission-only, Diffuse, custom node group) exports grey or black — a warning names the material. Build materials as Principled BSDF with constant values or Image Texture inputs.
• Procedural Base Color is baked for you (Cycles, 2K cap, capped material count; meshes without UVs get a Smart UV Project first) and reported in baked. Procedural Metallic / Roughness / Normal / Emission / Alpha are NOT baked — set constants, or bake them to an Image Texture in your script; the warnings list tells you which channel was left procedural.
• Axis and units: model in Blender’s native Z-up, in metres; the export converts to the engine’s +Y-up (dimensions in the result is already +Y-up). A 2 m wall segment is dimensions.y ≈ 2.
• Naming: object names become node names in the imported scene. Name every object and material (obj.name = "Wall_2m_A"). The name argument names the .glb (res://assets/fabricated/<name>.glb unless out_path says otherwise) and the instantiated node; it is sanitized to [A-Za-z0-9_-].
• Determinism: seed anything random (random.seed(7), noise textures with fixed seeds). A re-run must produce the same mesh so the loop below converges.
• No network. Blender’s online access is off; scripts that fetch anything fail. Reference images and existing models come from the project on disk (below).

​

Minimal template

# Kit piece: 2 m wall segment with a door cutout, bevelled, one material.
import bmesh

def make_box(name, size, location):
    bpy.ops.mesh.primitive_cube_add(size=1, location=location)
    obj = bpy.context.active_object
    obj.name = name
    obj.scale = size
    bpy.ops.object.transform_apply(scale=True)
    return obj

wall = make_box("Wall_2m_Door", (2.0, 0.2, 3.0), (0, 0, 1.5))

cutter = make_box("DoorCutter", (1.0, 0.4, 2.1), (0, 0, 1.05))
cutter.hide_set(True)          # hidden = helper: used by the boolean, never exported
cutter.hide_render = True

cut = wall.modifiers.new("Door", "BOOLEAN")
cut.operation = "DIFFERENCE"
cut.object = cutter
cut.solver = "EXACT"

bevel = wall.modifiers.new("Bevel", "BEVEL")
bevel.width = 0.02
bevel.segments = 2

mat = bpy.data.materials.new("KitStone")
mat.use_nodes = True
bsdf = mat.node_tree.nodes["Principled BSDF"]
bsdf.inputs["Base Color"].default_value = (0.55, 0.52, 0.48, 1.0)
bsdf.inputs["Roughness"].default_value = 0.85
wall.data.materials.append(mat)

​

The loop

1. summer_get_project_context — confirm the engine is up and which project is bound; read projectPath if the script needs a file from the project.
2. summer_world_snapshot — the BEFORE baseline; keep snapshot_id.
3. summer_fabricate_3d — source, name, import_to_scene: {parent, position?}, and target_size only when the asset is not dimension-authored (a hero prop whose size you are normalizing, not a kit piece). Default max_seconds 120 covers boot + script + bake + export for ordinary pieces; raise it (up to 600) for exact booleans on dense meshes or several bakes.
4. Read the result before looking at anything else. ok and ran; objects[] (each with vertices, faces, triangles, materials, modifiers) against what you meant to build; dimensions in +Y-up metres against the spec; skipped for pieces that vanished because they were hidden; warnings for grey-material and unbaked-channel problems; baked for what the bootstrap did to your materials; output for your own print()s. A non-zero exit_code after a validated export is a warning, not a failure — the artifact is what was verified.
5. summer_snapshot_diff from_id:<the id> — the structural receipt: exactly one new subtree under parent named <name>, nothing else changed.
6. summer_screenshot — look at it. target:"scene" framing:"camera" when materials or lighting matter; a preset framing for silhouette and scale checks.
7. Iterate on the script and re-run with the same name — the .glb is overwritten in place (overwrote_existing: true), and the previously instantiated node is still in the scene: remove it with summer_remove_node before re-importing to scene, or import without import_to_scene and let the existing instance pick up the new file.
8. summer_save_scene once the piece is right. Instantiation is one undo action in the open scene, not a save — an unsaved instance is lost when the editor closes.

​

Post-processing a generated model

import os
src = os.path.join(PROJECT_DIR, "assets", "generated", "goblin_statue.glb")   # PROJECT_DIR from summer_get_project_context.projectPath
bpy.ops.import_scene.gltf(filepath=src)
meshes = [o for o in bpy.context.scene.objects if o.type == "MESH"]
for o in meshes:
    bpy.context.view_layer.objects.active = o
    o.select_set(True)
    dec = o.modifiers.new("Decimate", "DECIMATE")
    dec.ratio = 0.25
    bpy.ops.object.mode_set(mode="EDIT")
    bpy.ops.mesh.select_all(action="SELECT")
    bpy.ops.uv.smart_project(angle_limit=math.radians(66), island_margin=0.02)
    bpy.ops.object.mode_set(mode="OBJECT")

​

Shatter fragments without add-ons

​

Failure taxonomy — read failure_reason, then act

​

Licensing and attribution

• Blender is the user’s. Summer runs the executable they installed as a separate process and talks to it only through arguments, files, and the exit code. Nothing in Summer links against Blender or imports bpy; the small export bootstrap the engine writes to a scratch directory is a separately licensed GPL file precisely because it does. Do not move project logic into bpy scripts expecting it to stay proprietary.
• Output is unencumbered. Meshes made with Blender belong to the user; the .glb in their project carries no Blender licence obligation.
• Scripts you write here are created on the user’s machine and never distributed by Summer. If you adapt a bpy snippet from elsewhere, respect its licence — prefer your own code or CC0 sources, and record the origin in .summer/memory/decisions/ when it matters for the project.
• Trademark. “Blender” is a trademark of the Blender Foundation. Refer to it factually as the dependency (“requires Blender”); never describe the feature as powered by, built on, or branded with Blender, and never use its logo. Summer’s name for this capability is mesh fabrication.
• Imported library assets keep their own licences (assets.search results carry license); fabrication does not change that.

​

Red Flags — STOP

• asset-strategy — the route decision for every “I need a [thing]”.
• environment-kit, prop-model, character-model — the generation and library specialists fabrication defers to.
• scene-scripting — in-scene geometry, placement loops, and wrapping fabricated pieces in bodies and collisions.
• verifying-scenes and verification-before-completion — the evidence discipline after import.

​

From a shell

​

Related skills

• asset-strategy: Route any ‘I need a [thing]’ asset request to the right skill: 2D, 3D, audio, video, VFX or animation.
• environment-kit: Generate a modular environment kit: walls, floor tiles, pillars, doors, arches in one visual style.
• prop-model: Generate one static 3D prop (sword, barrel, chest, lantern, statue): one object, no rig, a MeshInstance3D.
• character-model: Generate a rigged humanoid (player, NPC, enemy, boss) from a T-pose reference, previewed before rigging.
• scene-scripting: Build scenes, levels, HUDs and wiring with one editor GDScript (summer_run_script) instead of call chains.
• verifying-scenes: Prove scene work landed: snapshot, diff, screenshots, runtime reads, 3D audits, shot sheets and zooms.
• verification-before-completion: Run verification and read its output before claiming work done, fixed or passing: evidence first.