Skip to main content
skill CX Codex

steve-sheet-metal — Claude Code skill: what it does, how to install

The steve-sheet-metal Claude Code skill supports sheet-metal modeling in Steve CAD. Load it before writing code that uses sheet_* features.

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-sheet-metal -a claude-code
Open on GitHub

What steve-sheet-metal does

The skill describes sheet-metal work in Steve CAD, from base panels and bends to flanges, hems, cuts, flat patterns, DXF, and diagnostics. Load it before any code that calls sheet_* features.

For local model edits, it directs the agent to read the document with cad_read, apply changes with cad_build, then inspect the result with cad_inspect. Sheet thickness, bend radius, and K-factor can come from rules or bend and gauge tables. A K-factor reflects the shop process, not just the material, and its source should stay attached to the sheet rules.

What it helps with

  • build a sheet-metal base from a sketch
  • add bends and flanges to a panel
  • create a flat pattern and DXF
  • convert a flat solid into sheet metal

Example prompts for the agent

  • Create a sheet-metal part from this sketch and add a flange to the selected edge.
  • Add bends to this part and record the source of the K-factor.
  • Convert this flat part to sheet metal and create a flat pattern.

How to install steve-sheet-metal

1Skills CLI (Vercel)

npx skills add stevecad/steve --skill steve-sheet-metal -a claude-code

2Manually: put the files in place

~/.claude/skills/steve-sheet-metal/SKILL.md

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

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

Questions about steve-sheet-metal

How do I install steve-sheet-metal in Claude Code?

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

What does steve-sheet-metal do?

It covers sheet-metal modeling in Steve CAD, including bend rules, sheet features, flat patterns, DXF, and diagnostics. Load it before code that uses sheet_* features.

How should I set the K-factor in steve-sheet-metal?

Treat the K-factor as a shop-process input rather than a fixed material property. Measured values can go into a BendTable, and the source belongs with the sheet rules.

Source text

SKILL.md · Apache-2.0
---
name: steve-sheet-metal
description: >-
  Native sheet metal (sheet_* features): rules and gauge/bend tables, flanges, hems, jogs, tabs, bends, corners, reliefs, rips, reusable lance/louver/dimple/emboss tools, unfold/refold, flat patterns, DXF, SM_* diagnostics. Load before any sheet_* code.
---

## 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



# Sheet metal

Sheet-metal features are ordinary `Model` or `Component` calls, in millimetres and degrees, with the
id first. There is no separate settings statement: the sheet's rules live on the call that starts
it (`sheet_base`, `sheet_roll` or `sheet_convert`).

## Starting a sheet

```python
from steve import Model, SheetMetalRule

thickness = 1.5  # mm Sheet thickness
radius = 1.5  # mm Inside bend radius

rule = SheetMetalRule(thickness, radius, 0.44, name="1.5 mm steel", source="Estimate by STEVE, not shop-calibrated")
model = Model()
with model.sketch("sketch_1", on="XY") as s:
    s.rect("r1", (-40, -25), (40, 25))
model.sheet_base("base", "sketch_1", rule=rule)
# or explicit: model.sheet_base("base", "sketch_1", thickness=1.5, radius=1.5, k_factor=0.44,
#                               source="Estimate by STEVE, not shop-calibrated")
```

- The base sketch is the **top** reference surface; material goes below it.
- K-factor is a shop process input (0–1, typically 0.3–0.5), not a material constant.
- **Provenance, always.** Every sheet's rules carry `source=`: on the `SheetMetalRule` (or table), or on
  `sheet_base`/`sheet_roll`/`sheet_convert` when the values are written there. The app shows it, and the
  DXF manifest sends it to the fabricator, so it must never pass a guess off as shop data:
  - Any value you chose yourself (thickness, radius or K the person didn't give):
    `source="Estimate by STEVE, not shop-calibrated"`. Name what you estimated when only part is yours,
    e.g. `"Estimate by STEVE (K-factor); thickness and radius from the user"`. Say so in your reply and
    suggest getting the fabricator's K-factor or bend table.
  - Values the person gave: record that, e.g. `source="From the user: K 0.38, their shop chart"`.
    Never use the word "estimate" for them.
  - A chart the person pastes becomes a `BendTable`/`GaugeTable` whose `source=` names it.
  - Keep an existing `source` unless the values it describes change.
- `BendTable([{"thickness", "radius", "angle", "allowance"|"deduction"|"k_factor"}, …],
  interpolate=False)` gives measured allowances. Pass `bend_table=table` to the rule. Lookup is
  exact (optional angle interpolation), with no extrapolation and no silent K fallback.
- `GaugeTable({"16ga": {"thickness": 1.5, "radius": 1.5, "k_factor": 0.44}}, material=…,
  bend_table=…)`, then `gauges.rule("16ga")`, for gauge-driven parts.
- `sheet_roll(id, width, angle, rule=…, on="XY")` makes an open cylinder (angle < 360°; the rest is the
  seam). It starts at the plane's origin, tangent to the plane, runs `width` along the plane's X, and
  its first material heads along the plane's +Y. A positive angle curls toward the plane's normal
  around an axis one inside radius above the origin (inside face on the plane); a negative angle
  curls away around an axis radius + thickness below it (outside face on the plane). Example:
  `on="YZ"` puts the axis at world (r, y, 0), and the arc starts at 180° seen in X–Z.
- `model.move(id, bodies=[…], translate=…, rotate=…)` keeps a body sheet metal: its flat, DXF and
  later `sheet_*` features stay valid. Build a roll on its default plane and place it with a move.
  A `copy=True` copy of a sheet is a plain solid; build a second sheet when it needs its own flat.
- `sheet_convert(id, face="plate.top", rule=…)` turns a uniform flat solid (e.g. an imported plate)
  into sheet metal. Bent or variable-thickness solids are rejected.

## Edges: the rim

Flanges, hems, jogs and contours attach to one straight **outer top boundary**:
`"edge(base.side(r1.right)|base.top)"`. Use the side face's name and the panel's `top`. Picking an
edge in the viewport gives this name.

Panel names:
- faces: `id.top`, `id.bottom`, `id.side(<sketch entity>)`;
- flange sides: `id.side(start|end|left|right)`;
- bend faces: `id.bend.inner|outer|start|end`;
- a contour's walls: `id.1`, `id.2`, …; a jog's rise: `id.rise`;
- a `sheet_cut`'s walls: `<cut id>.side(<sketch entity>)`, like an extruded cut (a hole drawn as
  circle `h0` and cut by `hole_cut` is `hole_cut.side(h0)`, a cylinder);
- names last: after a `sheet_bend`, a hole or edge that moves whole onto the bent leg keeps its name
  (`base.side(u0)`, `hole_cut.side(h0)`), an edge the bend line trims is `<bend id>.side(<entity>)`,
  and the leg's top is `<bend id>.top`. Later cuts, flanges and hems keep them too.

Dimension holes on the drawing by these names; a hole's wall seen round gives its centre, so hole to
hole and hole to edge need no construction circles:
`{"view": "front", "refs": ["hole_cut.side(h0)", "hole_cut.side(h1)"]}`.

## Flanges

```python
model.sheet_flange("wall", "edge(base.side(r1.right)|base.top)", length=20, angle=90,
                   position="bend_outside", length_reference="tangent")
```

**Angle:** the bend angle from flat. Positive bends toward the top normal; negative bends down.

**`length_reference`** (what the length measures to):
- `"tangent"` (default): the straight part after the bend;
- `"outer_sharp"`: to the outside virtual sharp. Drawings and shops usually dimension this. Use it when
  the person gives outside dimensions.
- `"inner_sharp"`: to the inside virtual sharp.

**`position`** (where the flange sits relative to the edge):
- `"bend_outside"` (default): the bend starts at the edge, so the part grows;
- `"material_inside"`: the parent is trimmed so the flange's outside stays at the original edge,
  which keeps the outside dimension;
- `"material_outside"`;
- `"centered"`.

Other options:
- `offset=` moves the bend line outward (positive).
- `up_to=<plane or face>` with optional `end_offset=` replaces length.
- `gap_start=` / `gap_end=` shorten the flange from either end of the edge, for corner clearance.
- `radius=` overrides the sheet radius. `k_factor=`, `allowance=` or `deduction=` override the
  development.
- `relief="rectangular"` or `"round"` (with `relief_width`, `relief_depth`; default = thickness) for
  partial-width flanges.
- `miter_gap=0.5` trims two perpendicular coplanar return lips that would overlap, leaving that gap.
  Apply it before adding children to those lips.

## Other features

| Call | What it does |
|---|---|
| `sheet_contour(id, edge, segments=[{"length": 20, "angle": 90}, {"length": 15, "angle": -90}])` | Chains walls (L, U, Z, hat sections), up to 32 segments. |
| `sheet_hem(id, edge, length=6, gap=1, direction="up")` | Open 180° hem. The inside radius is gap/2. |
| `sheet_jog(id, edge, offset=10, length=15, angle=45)` | Step up (+) or down to a parallel panel. |
| `sheet_tab(id, panel="base", bounds=(x0, y0, x1, y1), gap=1, angle=45)` | U-cut formed tab, in panel-local coordinates (base: its sketch's XY). The hinge is at y0; the tab reaches toward +Y. |
| `sheet_bend(id, panel="base", start=(50, 30), end=(50, 0), angle=90)` | Bends an existing blank along a line. The material left of start→end moves. Apply before flanging that panel. |
| `sheet_corner(id, panels=["right", "front"], gap=0.5)` | Butt-closes two perpendicular 90° walls. The first wall stops `gap` short; the second covers. Do this before further flanges on those walls. |
| `sheet_relief(id, "sketch", panel="base")` | Sketched notches open to an edge (corner and bend reliefs). |
| `sheet_cut(id, "sketch", panel="base")` | Through-cuts inside one flat panel. Sketch on the panel face (`on="base.top"`). |
| `sheet_unfold(id, fixed="base")` → `sheet_cut(...)` → `sheet_refold(id)` | Cuts across bends: the bend crossings must be rectangles aligned with the bend axis. |

**Never use ordinary solid features (extrude-cut, hole, fillet) on a sheet body.** They invalidate
its flat pattern. Use `sheet_cut` / `sheet_relief`.

## Rip and form tools

`sheet_rip` has three explicit targets:

- `sheet_rip(id, panel="base", start=(0,15), end=(20,15), gap=0.5, side="center")`
  cuts a straight panel-local slit reaching an outer boundary. `left`/`right` are
  relative to start→end. It cannot sever an attached bend or leave a disconnected panel.
- `sheet_rip(id, bend="wall", gap=0.5, split_body="detached_wall")` separates a
  native bend into two independently exported sheet bodies. The new body name is
  mandatory. Gap is the chord between inside curved edges; remaining bend angles
  and proportional developed lengths are recorded, with `allowance_method="rip_proportional"`.
- `sheet_rip(id, face="tube.side", gap=1, rule=rule, seam_angle=30)` verifies and
  opens a complete uniform circular tube. Rule radius is the tube's inside radius;
  gap is an inside chord. It rejects cones, eccentric/nonuniform walls and other shapes.
  Seam angle is around the selected cylinder's axis from its native X direction.

Define a reusable tool, then place it in panel-local XY:

```python
from steve import SheetMetalForm
tool = SheetMetalForm("louver", width=12, length=20, gap=0.5, angle=30,
                      name="Example vent", source="Example tool geometry; qualify with the shop")
model.sheet_form("vent", tool, panel="base", at=(20,20), angle=90, direction="up")
```

- `lance`: `width`, `length` (developed tab blank), `gap`, optional `angle=30`,
  `radius=sheet radius`. A U-cut bent tab with exact bend development.
- `louver`: `width` (clear roof width), `length` (straight inclined roof), `gap`
  (front blank slit), optional `angle=30`, `radius`. Closed drawn side walls and an
  open lip. Its side-wall junctions use a nominal gauge envelope.
- `emboss`: circular raised land `diameter`, `height`, optional `angle=45` (wall
  slope) and `radius`. Smooth, normal-offset plane/cone/torus surfaces.
- `dimple`: the emboss dimensions plus `hole_diameter` (formed) and explicit
  `flat_hole_diameter`. Zero flat hole means piercing after forming. Never infer
  the blank hole from the finished hole; use the user's/toolmaker's dimension.

Forms support rotation, `direction="up"|"down"` and edge/form `clearance` (default
thickness). Keep the footprint wholly within a planar panel; bends and later cuts
cannot cross it. A form wholly on the moving side of a sketched bend follows it.

Pressed forms have a **nominal blank**, not a computed strain-based development.
Their marks/centers are on `FORM_UP`, `FORM_DOWN`, `FORM_CENTER`, never `CUT`.
The main DXF excludes form marks; the ZIP's separate `.forming.dxf` includes them.
Only the declared slit/pre-pierce and lance clearance are cut. The ZIP also includes
a forms CSV; JSON carries definitions, resolved dimensions and `SM_FORM_NOMINAL_BLANK`.
Do not claim those forms predict draw-in, thinning, springback or supplier readiness.

## Check the build

- `read_design` → `model.metadata.sheet_metal.summary`: per body, thickness, bend count, flat
  bounds and area.
- The full `sheet-metal.json` has:
  - rules with provenance (`source`, bend table);
  - bends (angle, radius, K, allowance);
  - the flat outline;
  - `diagnostics`, each with code, severity, message, feature/entity and measured/limit:
    `SM_FLANGE_TOO_SHORT`, `SM_BEND_RULE_MISSING`, `SM_FEATURE_NEAR_BEND`, `SM_FLAT_OVERLAP`,
    `SM_MATERIAL_OVERLAP`, miter failures.
- A failed feature leaves the previous sheet intact. Fix the call named in the error.
- `manufacturing_validation` is `not_assessed`. A "ready" sheet means valid geometry and a valid flat
  pattern, not supplier approval. For manufacturability, load `dfm-sheet-metal`; for a SendCutSend
  order, `sendcutsend-preflight`.
- Full builds export a ZIP: a DXF per body (layers `CUT`, `BEND_UP`, `BEND_DOWN`, `ROLL`; mm; exact
  arcs), a bend-table CSV and an SVG drawing.
- For a shop drawing of the blank, add the `flat` view to a `Drawing` (load `steve-drawings`):
  `Drawing(result, views=("front", "top", "flat"))`. It shows the same development as the DXF, with the bend lines
  and their notes and, with dimensions, the blank's overall size, so never draw the blank by hand.

## Not supported (say so)

- arbitrary curved or diagonal cross-bend cuts;
- general corner and miter solving beyond the cases above;
- closed, rolled or teardrop hems;
- lofted transitions;
- recognising already-bent imported parts;
- arbitrary custom forming solids, rectangular embosses and beads beyond the listed tools;
- general cone rips or reverse seam-to-bend joining;
- bend sequencing and tooling collisions;
- nesting.

© stevecad · Apache-2.0 · stevecad/steve

Similar skills

SKILL.md skills catalog →

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-materials 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. 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