Skip to main content
skill CX Codex

steve-materials — Claude Code skill: materials and setup

The steve-materials Claude Code skill assigns materials and changes the look of CAD parts. Load it before editing finishes, checking mass, or placing an image on a model.

Apache-2.0 ★ 86 updated 2026-11-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add stevecad/steve --skill steve-materials -a claude-code
Open on GitHub

What steve-materials does

This skill assigns materials and visual treatments to parts in a CAD model, and handles questions about mass. A material can apply to a whole part or selected bodies, with a chosen colour or finish. Use model.appearance(...) for a visual treatment without a material; model.decal(...) places an image on flat or curved faces.

The instructions cover local document work: the agent reads with cad_read, inspects geometry through cad_inspect, and applies edits with cad_build. An unrecognized material ID is reported with suggestions in the build problems; it does not stop the build. A custom material needs a my: ID supplied by the user, which the agent must not invent.

What it helps with

  • assign a material to a part or selected bodies
  • set a surface colour and finish
  • calculate a part's mass from its material
  • place a logo or image across model faces

Example prompts for the agent

  • Assign aluminum 6061-T6 to the whole part and report its mass.
  • Give extrude_2 a brushed stainless-steel finish.
  • Place the logo image across the part's curved surface.

How to install steve-materials

1Skills CLI (Vercel)

npx skills add stevecad/steve --skill steve-materials -a claude-code

2Manually: put the files in place

~/.claude/skills/steve-materials/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/steve-materials/

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

Questions about steve-materials

How do I install steve-materials in Claude Code?

Run npx skills add stevecad/steve --skill steve-materials -a claude-code. The skill file is installed at ~/.claude/skills/steve-materials/SKILL.md.

What does steve-materials do?

It assigns materials to parts or individual bodies, applies appearance without a material, and places images on faces. It also handles mass questions and material ID problems.

How does appearance differ from a material in steve-materials?

model.appearance(...) changes visuals without assigning a material. model.material(...) assigns a material used in mass calculations.

Source text

SKILL.md · Apache-2.0
---
name: steve-materials
description: >-
  model.material(...) for parts and bodies: library ids, finishes, colours, mass and material problems; model.appearance(...) for a look without a material (paint, glazing, presentation, no mass), on the part, bodies or some faces (faces=, bands and trims without splitting solids); model.decal(...) image decals on flat or curved faces, across several faces. Load before choosing or assigning materials, changing how a part or body looks, answering mass/weight questions, or putting a logo, label or screen image on a part.
---

## Steve execution rules

This skill adapts Steve Studio's CAD guidance for Steve running locally. The modeling
examples below describe the shared CAD runtime. These local execution rules take
precedence over upstream service workflows and tool names in that reference.

- Read the active document with `cad_read`; inspect built geometry with `cad_inspect`.
  Do not guess persistent face names, document shapes, revision IDs or import hashes.
- Apply source changes with `cad_build(document=..., expected_revision=...)`, preserving
  the document schema returned by `cad_read`. Use `cad_set_parameters` for parameter
  changes. Inspect the build result and errors before reporting success.
- `cad_api_reference` provides installed Model, Sketch, Component and Design signatures.
  The installed runtime and available tool schemas are authoritative if reference
  examples describe newer or unavailable capabilities.
- Export built geometry using `cad_export` with the current revision and a supported
  format. Drawing PDF/SVG/DXF workflows are available in the drawing UI; do not claim
  the geometry export tool exports drawings unless its schema supports that.
- Find standard parts or locally imported McMaster parts with `cad_find_parts`, then
  cache a part using `cad_import_catalog_part`. Use the returned import hash with
  `Model.import_step`. Import arbitrary STEP files through the local Import UI.
- `cad_source_package` reads a transferable source package; `cad_import_package`
  imports supplied root and dependency documents locally. These do not publish.
- Upstream `read_part`, `edit_part`, `read_design`, `inspect_model`, upload-ticket,
  workspace/server/document-ID and cloud export instructions are reference context,
  not available local commands. Use the local tools above. Do not sign in to Studio,
  upload, publish, or call a connected Studio MCP merely to perform local CAD.
- SaaS upload quotas are not local limits. Simulation, electronics, CAM, teams and
  cloud jobs are outside this local CAD skill. Do not invent their availability.
  References to unbundled skills do not imply those features are installed.

## Upstream CAD reference



# Materials

Materials are **statements, not features**: no id, nothing rebuilt. They version, branch and
merge with the code.

```python
model.material("aluminum-6061-t6")                                         # the whole part
model.material("stainless-304", bodies=["extrude_2"], finish="brushed")     # some bodies
model.material("abs", bodies=["boss"], color="#1f2328")                     # appearance tint
```

- In a design component, use the component's variable: `plate.material("aluminum-6061-t6")`.
- `bodies=` overrides the part material for those bodies whatever the order; for one body the last
  call wins.
- `finish=` and `color="#rrggbb"` change only how the body renders (for a look with no material, see
  "Appearance without a material" below). Finishes include polished,
  machined, brushed, bead-blasted, cast, anodized, painted, powder-coated, glossy, satin, matte,
  textured, clear, frosted, natural and varnished; which apply depends on the material.
- Write material statements before `result = model.result()`.

## Ids

Ids are library slugs, e.g.:
- metals: `aluminum-6061-t6`, `aluminum-7075-t6`, `stainless-304`, `stainless-316`, `titanium-6al-4v`,
  `steel-s235jr`, `steel-a36`;
- plastics: `abs`, `pc`, `pla`, `pa6`, `pom-copolymer`;
- glass: `glass-soda-lime`;
- sheet-metal stock: `aluminum-5052-h32`, `steel-dc01` (cold-rolled, SPCC / SAE 1008 / ASTM A1008 CS),
  `steel-dx51d-z275` (hot-dip galvanized, G90 / ASTM A653 CS);
- plate: `steel-a36`, `steel-a572-50` (ASTM A572 Grade 50 HSLA), `steel-ar400` and `steel-ar500` (abrasion-resistant
  wear plate; AR grades are producer-defined, so their strengths are one producer's typical values);
- wood-based panels: `wood-mdf`, `wood-hdf` (hardboard), `wood-particleboard` (chipboard), `wood-osb`,
  `wood-plywood-softwood`, `wood-plywood-hardwood`. Panel density varies by product, and each has one producer's
  typical density; for a specific board's density, suggest the person's own material (below).

The library has a few hundred engineering materials, with sources. If you're unsure of an id, assign
your best guess and read the build's `modeling.materials.problems`: unknown ids come back with
suggestions and their names. They are reported, never fatal. A guess is matched against ids, names and
designations (other names, EN material numbers, comparable AISI/UNS grades), so `steel-c45`,
`steel-1-6587`, `steel-18crnimo7-6` or `steel-aisi-8620` finds the library's id for it, first.

Steels are named by their EN grade (`steel-<grade>`); AISI/SAE numbers aren't ids. Gear and shaft
steels in the library:
- `steel-17crnimo6`: 17CrNiMo6, 1.6587, the same material as 18CrNiMo7-6;
- `steel-20nicrmo2`: 20NiCrMo2, 1.6523, comparable to AISI 8620;
- `steel-34crnimo6`: 34CrNiMo6, 1.6582, comparable to AISI 4340;
- `steel-15crni6`, `steel-30crnimo8`, `steel-36crnimo4` (≈ AISI 9840), `steel-1c45` (C45, ≈ AISI 1045).

16MnCr5, 20MnCr5, 42CrMo4 (AISI 4140) and AISI 9310 aren't in the library: say so, offer the
closest grade above, or suggest the person adds the grade as their own material (below).

## The person's own materials

A person can keep their own materials (Materials dialog → My materials): new ones, or copies of a
library material with values they changed (marked "Modified"; the library's stays as it is). Their ids
start with `my:`, e.g. `model.material("my:bronze-c932")`, and give mass and simulation values like a
library id. Only the person makes, edits or deletes them, in the app; you can't see the list, so use
an id they give you (the dialog shows it under the name) and never invent a `my:` id. An unknown or
deleted one is reported in `problems`. For a material the library lacks, suggest they add it there.

## What the build reports

- Per body: `material`, `finish`/`color`, and `mass` in grams (exact volume × library density).
- `modeling.materials`: `default`, total `mass` (null unless every body has a material),
  `unassigned` bodies and `problems`.
- Simulations take materials from the design. A study can override them per body.

## Appearance without a material

`model.appearance(...)` sets only how the part or some bodies look. It is a statement like
`model.material` (no id, the same `bodies=` rule, the last call for a body wins) but never gives a
density: mass, simulation and machining don't see it.

```python
model.appearance(color="#1c1c1e", finish="matte")                                # the whole part
model.appearance(color="#9ec5e8", opacity=0.35, roughness=0.05, bodies=["canopy"])  # glazing
model.appearance(color="#c0c4c8", metalness=1, roughness=0.3, bodies=["inlet_cone"])
```

- `color` hex; `finish` a finish id from the list above (any finish, whatever the material);
  `opacity`, `roughness`, `metalness` numbers from 0 to 1. Give at least one.
- Use `appearance` for presentation: paint, glazing, colours of proxy, concept or exterior geometry
  whose inside isn't modelled. Use `material` only when the physical material is meant: it sets the
  mass and the simulation inputs. Never assign a material just to get a colour or see-through look.
- Both on one body: the appearance wins for every field it sets, the material still gives the mass.
- The build reports each body's `appearance`, and `modeling.appearances.problems` (unknown bodies).
  STEP exports and inspection views take the appearance colour.

### Some faces of a body

`faces=` gives some faces of a body their own look: bands, trims, the inner and outer sides of a
door, a rim detail. Geometry, solids, mass and simulation don't change, so **never split a valid
solid just to colour part of it**.

```python
model.appearance(color="#c8102e", finish="painted", faces=["strut.side_faces"])     # a red band
model.appearance(color="#2b2b2b", finish="matte", faces=["door.start", "door_lip.faces"])
inner = ["door.end", "select(faces, '<Y', on='door')"]                               # a named face set
model.appearance(color="#e8e8e0", faces=inner)
```

- `faces=` takes what `faces()` takes: one reference or a list. Use stable references (a feature's
  named faces such as `extrude_1.end`, `<id>.side_faces`, `<id>.faces`, or `select(...)`), not
  numbered `.face(<n>)` ones, which renumber when the geometry changes. A named face set is a Python
  list of references in a variable.
- References resolve on the finished model at every build, so the look follows the geometry. Write
  the statement after the features that make the faces, before `result = model.result()`.
- A face's look wins over its body's, a body's over the part's; for one face the last call wins. A
  face look replaces the body's look for that face (give every field it needs). Not with `bodies=`.
- The build reports each body's `face_appearances` (`[{faces: [indices], color, …}]`). A reference
  that names no face now is in `modeling.appearances.problems`; the build still succeeds. STEP
  exports carry face colours.

## Decals (images on faces)

A decal shows an image on a part's faces: a logo, a label, a screen, markings on a curved skin. It is a
feature (id first) but appearance only: geometry, mass and exports (STEP, STL) don't change.

```python
model.decal("logo", image="img_3fa2b9c41d07", on="extrude_1.end", width=40)   # height follows the image
model.decal("screen", image="img_9c0e41aa2b10", on="extrude_1.end", width=60, height=34, at=(10, 0), rotation=90)
# Curved or several faces: projected onto the faces turned toward it.
model.decal("roundel", image="img_51c0de7a9e22", on="tank.side", width=30)
model.decal("marking", image="img_7d2a90b3c5e1", on="fuselage.side_faces", width=120, height=20,
            at=(300, 0, 45), direction=(0, 0, 1), depth=30)
# Wrapped: follows the skin like a vinyl sticker, keeping its size where the surface curves away.
model.decal("walkway", image="img_7d2a90b3c5e1", on="fuselage.side_faces", width=400, height=40,
            at=(300, 0, 45), rotation=90, wrap=True)
```

- `image` is an uploaded image's id. `list_decal_images` lists the workspace's images. STEVE in the app
  adds an image the person attached in chat with `add_decal_image(attachment_id)` (the id in the image's
  label). An agent outside STEVE uploads a file from its machine with `request_upload` (a .png, .jpg or
  .webp): a one-time upload command whose response carries the id. Never invent ids.
- `on` is one face reference or several (a list, `select(...)`, `"loft_1.side_faces"`), all on one
  body; `rotation` in degrees. Use `inspect_model` to find face names and sizes.
- On **one flat face** the image lies on it: `at` is its centre in that face's sketch coordinates
  (default: the face's centre). Keep the decal inside its face.
- On **curved or several faces** (or with `direction=`/`depth=`) it is projected like a slide projector,
  continuous across seams: `at` is a point (x, y, z) in the part's coordinates on or near the faces,
  snapped onto them (default: the middle of the first face); `direction=(x, y, z)` the side it is seen
  from (default: the surface normal there); `depth` mm how far in front of and behind that point it
  reaches (default: half the image's larger side). Only faces turned toward the projector show it, so it
  never prints through to the far side of a fuselage or tube; it stretches where the surface turns away,
  so keep it on the part of a skin that faces it.
- **Projection or wrap?** Project markings seen from one side (a roundel, a logo, a window, a label on a
  bottle's front). Use `wrap=True` for stripes, bands, serial numbers and text that run round a body or
  along a curving skin: the image is laid along the surface, so a 400 mm stripe covers 400 mm of skin and
  keeps its height, where a projection would stretch it as the skin turns away. `at`, `rotation` and
  `direction` mean the same as for projection (the image's x starts tangent to the surface); `depth`
  doesn't apply (it is an error). A wrap can't go further round than the body's circumference.
- A cylinder or a cone carries any wrap without distortion. A large wrap on a doubly curved patch (a
  sphere, a nose cone's tip, a blended corner) must stretch toward its edges; the feature then builds with
  a warning saying so. Make it smaller or move it to a flatter part of the skin if that matters.
- The faces resolve again on the finished model at every build, like `model.appearance(faces=...)`;
  the feature's detail reports the body and its face indices. A reference that names no face is an
  error on the decal (by its name). Put decals after the features that make their faces.

## Choosing a material

- State the trade-offs: strength, stiffness, density, corrosion, machinability or printability,
  cost and finish.
- Library properties are typical values with sources, not certified minima. For safety-relevant
  choices, say the supplier's data sheet governs.

© stevecad · Apache-2.0 · stevecad/steve

Similar skills

SKILL.md skills catalog →
steve-jobs-design-review wondelai steve-jobs-design-review — a skill for Claude Code and Cursor that audits interfaces and feature scope against Steve Jobs' standards, stripping non-essential elements to focus entirely on user flow. CX Codex +1 3,800installs recipe-share-event-materials official googleworkspace The recipe-share-event-materials skill reads Google Calendar attendees and gives them reader access to a Google Drive file. Use it when meeting materials need to reach every guest. CX Codex +1 30,700installs threejs-materials CloudAI-X Skill for Claude Code, Codex, Cursor and other platforms: choosing and configuring three.js materials — from basic to PBR, toon shading and point clouds. Runs when you need to style a mesh, tune blending or switch to WebGPU. CX Codex +1 21,100installs threejs-materials-lighting gamedev-skills The threejs-materials-lighting Claude Code skill configures materials, lighting, and shadows in three.js scenes. It kicks in when meshes render black or washed out, shadows misbehave, or EffectComposer darkens the image. CX Codex +1 11,100installs investor-materials affaan-m The investor-materials skill for Claude Code creates and aligns pitch decks, one-pagers, financial models, and accelerator applications, keeping numbers consistent across fundraising documents. CX Codex +1 6,500installs r3f-materials EnzeD r3f-materials — a Claude Code skill that picks React Three Fiber materials for a surface and flags the cheaper options. Also runs in Codex, Cursor, Copilot, Gemini CLI and OpenCode. CX Codex +1 2,200installs

From the same set9

steve-surfaces The steve-surfaces Claude Code skill guides sweep, loft, and surface work in CAD models. It activates before creating or editing those features, or turning surfaces into solids. CX Codex +1 ★ 86repo stars steve-step-import The steve-step-import Claude Code skill guides STEP imports and edits to imported CAD bodies. It loads for changes to an imported part, assembly imports, or features broken by renumbered faces. CX Codex +1 ★ 86repo stars steve-standard-parts steve-standard-parts — a skill for Claude Code that imports standard components from step.parts and sets up fasteners in CAD models. Triggers before modeling purchased parts or bolting assemblies. CX Codex +1 ★ 86repo stars steve-sheet-metal The steve-sheet-metal Claude Code skill supports sheet-metal modeling in Steve CAD. Load it before writing code that uses sheet_* features. CX Codex +1 ★ 86repo stars steve-motion The steve-motion Claude Code skill defines component joints and motion in a CAD design. It activates for mechanisms, gear couplings, animations, or exploded views. CX Codex +1 ★ 86repo stars steve-designs The steve-designs skill for Claude Code covers CAD assemblies built from multiple components. It activates for design models, fit checks, and work on large assemblies. CX Codex +1 ★ 86repo stars steve-blender The steve-blender Claude Code skill builds Blender scenes with Python and bpy. It loads before an agent writes, edits, or reviews a Blender document. CX Codex +1 ★ 86repo stars steve-drawings The steve-drawings Claude Code skill creates engineering drawings for manufacture. It activates for requests to make, edit, or explain a drawing, title block, revision table, parts list, or cut list. CX Codex +1 ★ 86repo stars

Project sponsors

Companies that keep this analytics open