Skip to main content
skill CX Codex

blender-hardsurface-modeling — Claude Code skill: install & guide

blender-hardsurface-modeling — a skill for Claude Code guides hard-surface and prop modeling workflows in Blender 5.3. Sets up blockout rules, modifier pipelines, and topology checks.

MIT 621 installs ★ 2,624 updated 2026-11-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add EL4CTEO/blender-skills --skill blender-hardsurface-modeling -a claude-code
Open on GitHub

What blender-hardsurface-modeling does

Enforces mid-poly, high-to-low, and subdivision modeling pipelines for vehicles, weapons, and mechanical props in Blender 5.3. The workflow begins with a real-scale blockout before applying cuts, panel lines, or edge bevels.

The modifier pipeline relies on non-destructive modifiers ordered as Mirror, Booleans, Bevel, and Weighted Normal. It isolates cutters into dedicated collections, creates UV seams before bevel passes, and triggers automated setup through scripts/apply_stack.py. Python scripts configure attributes such as bevel_weight_edge and sharp_edge directly on mesh data.

Object scale must be applied with transform_apply(scale=True) before adding bevels or booleans, otherwise modifier offset distances distort across object space. Modeling passes end with verification in blender-asset-qa.

What it helps with

  • build non-destructive Mirror, Boolean, and Bevel modifier stacks
  • clean shading on flat faces using Weighted Normal and Smooth by Angle
  • select between mid-poly, subdivision, and high-to-low baking workflows
  • assign edge weights and seam flags via Blender Python mesh attributes

Example prompts for the agent

  • Set up a non-destructive modifier stack for a mid-poly vehicle body
  • Define cylinder segment counts for mechanical joints and bolts
  • Write a Python snippet to set bevel_weight_edge on 30-degree angles

How to install blender-hardsurface-modeling

1Skills CLI (Vercel)

npx skills add EL4CTEO/blender-skills --skill blender-hardsurface-modeling -a claude-code

2Manually: put the files in place

~/.claude/skills/blender-hardsurface-modeling/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/blender-hardsurface-modeling/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about blender-hardsurface-modeling

How to install blender-hardsurface-modeling in Claude Code?

Run npx skills add EL4CTEO/blender-skills --skill blender-hardsurface-modeling -a claude-code.

What does blender-hardsurface-modeling do?

It structures hard-surface modeling in Blender by providing rules for modifier sequences, topology distribution, and Python-driven attributes.

What is required to use blender-hardsurface-modeling?

It requires Blender 5.3 alongside blender-core models and blender-asset-qa.

Source text

SKILL.md · MIT
---
name: blender-hardsurface-modeling
description: Hard-surface and prop modeling in Blender 5.3 - blockout-to-detail flow, non-destructive modifier stacks (Mirror, Boolean Exact/Manifold, Bevel, Weighted Normal, Smooth by Angle), mid-poly vs subdivision vs high-to-low workflows, shading/custom normals, cylinder segment budgets, edge attributes from Python. Use for weapons, vehicles, props, architecture, mechanical parts.
license: MIT
metadata:
  author: blender-agent-skills
  version: "1.2.0"
---

# Hard-Surface Modeling

The execution model is in `blender-core`. Run `blender-asset-qa` after every modeling pass.

## Pick the workflow first
| Workflow | When | Output |
|---|---|---|
| **Mid-poly** (bevel + weighted normals, no bake) | modern games, props seen up close, fast iteration | game mesh directly; tiling materials/trim sheets |
| **High → low** (high via booleans+bevel or subd, low baked) | hero assets, unique textures, tight tri budgets | `_high` + `_low` → `blender-texture-baking` |
| **Subdivision** (support loops/creases + Subsurf) | renders, product viz, film | smooth surfaces, edges held by loops/creases |

## Procedure
1. **Blockout** at real scale (`ob.dimensions`) from primitives. Settle the silhouette and proportions before any detail. Check against references.
2. **Apply scale** (`transform_apply(scale=True)`) before bevels, booleans or solidify, because modifier distances use object space.
3. **Primary → secondary → tertiary** forms. Booleans for cuts and panels, then bevels. Small tertiary details go in normal maps/decals, or into the high-poly as "floaters" for baking.
4. **UV the base mesh now** (mid-poly). Bevel/Boolean modifiers propagate UVs, but after bevels no edge is sharp enough to auto-seam. Then **build the stack** with `scripts/apply_stack.py -- --objects Body --preset midpoly --cutters Cut1 Cut2`. Order: Mirror → Booleans → Bevel → Weighted Normal → (Triangulate at export).
5. **Shading check**: smooth shading + Weighted Normal (keep sharp). There must be no gradients across flat faces. View with a matcap or `look` in `solid` shading.
6. **QA** with `blender-asset-qa`, then apply the stack only on an export copy (`--apply`), keeping the editable source.

## Stack rules
- **Booleans**: put cutters in a `Cutters` collection with display `WIRE` and `hide_render=True`. Solver: `EXACT` (robust default), `MANIFOLD` (much faster, but inputs must be closed manifold), `FLOAT` (legacy fast, fragile with coplanar faces). With many cutters, use `operand_type="COLLECTION"`.
- Avoid coplanar boolean faces: extend cutters slightly past the surface. They also cause z-fighting.
- **Bevel**: `limit_method="ANGLE"` (30°), or `"WEIGHT"` with a `bevel_weight_edge` attribute for hand-picked edges. Turn on `use_clamp_overlap`, `harden_normals=True`, `miter_outer="MITER_ARC"`. Width ≈ 0.5–2% of the part's size, kept consistent across the asset.
- **Weighted Normal** after Bevel: `mode="FACE_AREA"`, `keep_sharp=True`, weight 50. Needs smooth faces (remove the `sharp_face` attribute or call `shade_smooth`).
- **Smooth by Angle** (4.1+, replaces auto smooth): `bpy.ops.object.shade_auto_smooth(angle=rad)` adds a GN modifier, or `shade_smooth_by_angle` sets `sharp_edge` destructively.
- **Mirror**: `use_clip=True`, `use_mirror_merge=True`. Model one half only at x ≥ 0.
- **Subdivision**: hold edges with support loops (a loop 1–5% of the face width from the edge) or `crease_edge` (0–1). Turn on `use_limit_surface`. Don't use creases if the asset goes to an engine.
- **Triangulate** only for export/baking (`keep_custom_normals=True`, `BEAUTY`). Triangulating the bake mesh and the export mesh identically keeps normal maps synced.

## Topology rules
- **N-gons**: fine on flat, non-deforming faces in mid-poly/game meshes. Never use them on curved surfaces or anything that subdivides or deforms.
- **Poles** (5+ edges) should sit on flat areas, never on a curvature peak or bevel.
- **Cylinder segments by on-screen size**: small (bolts) 6–8, medium (handles) 12–16, large (barrels) 24–32, hero/close-up 48+. Use multiples of 4 or 8 so booleans/mirrors line up with existing loops.
- **No long, thin triangles** across visible curved areas (shading and LOD artifacts).
- **Panel lines**: inset + extrude in (mid-poly) or a boolean groove on the high-poly, then bake.
- Spend density where the silhouette needs it, not on flat faces.

## Edge/face attributes from Python (4.0+ names)
```python
me = ob.data
bw = me.attributes.get("bevel_weight_edge") or me.attributes.new("bevel_weight_edge", "FLOAT", "EDGE")
cr = me.attributes.get("crease_edge") or me.attributes.new("crease_edge", "FLOAT", "EDGE")
sh = me.attributes.get("sharp_edge") or me.attributes.new("sharp_edge", "BOOLEAN", "EDGE")
bw.data[edge_index].value = 1.0; sh.data[edge_index].value = True
me.edges[edge_index].use_seam = True          # seams are still an edge property
```
Select sharp edges by angle in bmesh: `e.calc_face_angle(0) > math.radians(30)`.

## Gotchas
- A bevel that looks blobby or flips usually means unapplied/non-uniform scale or overlapping geometry (turn on clamp).
- A Boolean that returns nothing or garbage: the cutter isn't closed/manifold (Exact copes, Manifold fails), or its normals are inverted.
- Weighted Normal has no effect: faces are flat-shaded, or an earlier modifier destroyed the custom normals.
- 5.2: the GN `Mesh Bevel` node exists for procedural bevels inside node trees (`blender-geometry-nodes`).
- 5.3: LoopTools is built in (`mesh.relax_edge_loops`, `curve_edge_loops_between_selected`, `fit_edge_loops_to_annotation`, `space_edge_loops_evenly`). `mesh.primitive_quad_sphere_add(segments=4)` gives an all-quad cube-sphere: no pinched poles, so it subdivides and bevels cleanly.
- Trim-sheet/mid-poly assets: UVs go to the trim strips (`blender-retopology-uv`) and materials tile (`blender-pbr-materials`).

© blender-agent-skills · MIT · EL4CTEO/blender-skills

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set28

The whole set →
blender-animation blender-animation — a skill for Claude Code that automates Blender 5.3 animation via Python scripts. It handles keyframing, mocap retargeting, and rigging bake processes for game engines. CX Codex +1 757installs blender-export-pipelines The blender-export-pipelines Claude Code skill exports Blender assets with presets for game engines and other formats. It activates when an asset needs to leave Blender and the exported file needs checking. CX Codex +1 681installs blender-game-optimization The blender-game-optimization skill runs in Claude Code, Codex, Cursor and other platforms to optimize Blender 3D assets for real-time engine limits. CX Codex +1 657installs blender-pbr-materials blender-pbr-materials — a skill for Claude Code configures PBR materials and texture sets in Blender 5.3 following engine-ready rules. CX Codex +1 644installs blender-lighting-lookdev The blender-lighting-lookdev Claude Code skill sets up lighting, cameras and material look-dev in Blender 5.3. It activates for render scenes, asset presentations and consistent material checks. CX Codex +1 606installs blender-retopology-uv The blender-retopology-uv Claude Code skill covers retopology and UV work in Blender 5.3. Use it to turn a sculpt or scan into a game mesh, or prepare UVs for texturing and baking. CX Codex +1 603installs blender-texture-baking blender-texture-baking — a skill for Claude Code that runs Cycles baking pipelines in Blender 5.3. Triggers when transferring high-poly sculpt details to game assets or converting procedural node networks to images. CX Codex +1 587installs blender-rendering blender-rendering — a skill for Claude Code configures Blender 5.3 rendering for stills, animation, and turntables. It covers single-frame, animation, and turntable jobs. CX Codex +1 582installs

Project sponsors

Companies that keep this analytics open