Skip to main content
skill CX Codex

steve-step-import — Claude Code skill for STEP geometry

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.

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-step-import -a claude-code
Open on GitHub

What steve-step-import does

The skill explains how to bring STEP files into Steve, select individual solids, and add CAD features to imported geometry. It covers numbered face references as well as geometric selectors that resolve edges again after face numbering changes. Replacing a file can change face numbers, breaking references tied to those numbers.

The workflow uses Steve’s local CAD tools, including cad_read, cad_build, cad_inspect, and cad_api_reference; arbitrary STEP files go through the local Import UI. Imported solid geometry has no editable feature history, so its original dimensions cannot be changed. New features can still be added, cuts made, or the body remodeled natively. Import errors include unknown imports, unreadable files, files without solids, and out-of-range solid indices.

What it helps with

  • bring a STEP file into a Steve model
  • add a cut or fillet to an imported body
  • sketch on a face of imported STEP geometry
  • repair a feature after replacing its STEP source
  • reuse one imported part in several assembly positions

Example prompts for the agent

  • Import a STEP file and add a cut to the imported body.
  • Repair the fillet that broke after the STEP file changed.
  • Build an assembly from several STEP parts and place repeated components.

How to install steve-step-import

1Skills CLI (Vercel)

npx skills add stevecad/steve --skill steve-step-import -a claude-code

2Manually: put the files in place

~/.claude/skills/steve-step-import/SKILL.md

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

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

Questions about steve-step-import

How do I install steve-step-import in Claude Code?

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

What does steve-step-import do?

It covers importing STEP geometry, adding CAD features, and selecting faces. For references that must survive face renumbering, it describes geometric selectors.

Why can STEP face references break?

Replacing the source file can change face numbers. The skill describes geometry-based edge selection for features that need to remain valid after that change.

Source text

SKILL.md · Apache-2.0
---
name: steve-step-import
description: >-
  Imported STEP geometry: import_step, file-order face names (import_1.face(n)), adding features to imported bodies, and selector references that survive renumbered faces. Load when a part contains import_step or the person wants to change an imported file, or when a feature on numbered faces (import_1.face(n), model.add's code_1.face(n)) broke after an upstream change. Also load before bringing many parts or a whole assembly in from another CAD system.
---

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



# Imported STEP geometry

People import STEP files from the toolbar (or by dropping a file). The import becomes a feature
that names the upload by its content hash:

```python
model.import_step("import_1", "3f2a…(sha256)", name="Bracket", op="new", solids=None)
```

- `list_imports` shows the STEP files uploaded to this workspace and `insert_import` places one into a part or
  design. An agent outside STEVE uploads a file from its machine (or one it converted, e.g. from a mesh) with
  `request_upload(filename, size_bytes, sha256)` and runs the command it returns: a one-time ticket for that exact
  file. STEVE in the app asks the person to upload it (File → Import…, or drop it on the window). Never upload
  through a browser.
- `op="new"` (the default) adds one body per solid: `import_1` for one solid, `import_1_1`,
  `import_1_2`, … for several.
- `op="join"`, `"cut"` or `"intersect"` combine every imported solid with the target body.
- `solids=[k, …]` imports only those solids (1-based, file order).

## Many parts or a whole assembly

Each upload takes one ticket, at most 60 an hour per workspace (more returns 429 `too_many_tickets`);
re-requesting a file that is already uploaded returns `already_uploaded` and takes none. So don't upload
one file per part:

- Export the parts together as one STEP (or a few, up to 20 GB each) and give each component its own
  solid of it: `bracket.import_step("import_1", sha, name="Bracket", solids=[3])` in
  `components/bracket.py` (load steve-designs). The upload result and list_imports give `solid_names`,
  the file's solids in order; map them to components before writing.
- One build can use at most 1024 imported files and 20 GB of them together, counting every component and
  linked document it builds, so keep the split to a few files.
- Import each distinct part once, as a component, and place it as many times as it appears with
  `design.add(..., name=..., at=...)` or `design.pattern`, not one import per placed copy.
- Rename imported names before writing them: component ids and joint, coupling and fit check
  names are lowercase letters, digits and underscores (`Bracket__Left_Mount` → `bracket_left_mount`), and file names at most 64 characters.
  Keep a table of old → new names in a data file if the person needs to map them back.

## Face names

- Faces are named in file order: `import_1.face(12)`, or `import_1.solid(2).face(3)` when the
  file has several solids. Groups: `import_1.faces`, `import_1.solid(2).faces`.
- These names survive later features, so you can fillet imported edges, sketch on imported faces,
  cut into imported bodies and move them:

```python
with model.sketch("sketch_1", on="import_1.face(4)") as s:
    s.circle("c1", (0, 0), 3)
model.extrude("cut_1", "sketch_1", distance=-5, op="cut")
model.fillet("fillet_1", edges=["edge(import_1.face(4)|import_1.face(7))"], radius=1)
```

- There is no feature history inside an imported solid: you can't change its original dimensions,
  only add features to it, cut it, or remodel it natively.
- Use `inspect_model` and the selection context (the person's picks name faces like
  `import_1.face(n)`) to find the right face. Don't guess numbers.
- Face numbers change when the file is replaced (and `model.add` numbers change when its code
  adds or removes faces), breaking `edge(import_1.face(4)|import_1.face(7))`. For features that
  should survive that, reference the geometry instead; it is re-resolved at every build:

```python
model.chamfer("chamfer_1", edges=cq.selectors.BoxSelector((-1, -1, 19), (1, 1, 21))
              & cq.selectors.TypeSelector("CIRCLE"), distance=1.5)        # the circle centred at (0, 0, 20)
model.fillet("fillet_2", edges=['select(edges, "%CIRCLE and >Z", on="import_1")'], radius=1)
```

  `BoxSelector` matches by centre position; combine with `&`, `+`, `-`. `on=` limits a string
  selector to one body (or a feature's faces). Make selectors specific (position plus type), and
  check the feature's `detail.edges` count: a broad one can match new edges after a change.

## Errors

These are recorded on the feature, and later features still run:
- an unknown import;
- an unreadable file;
- a file with no solids (surfaces only);
- a solid index out of range.

`detail` reports `solids`, `imported`, `bodies`, `faces` and the file's `names`, one per solid in file order: the
body's own name, as `Component / Body` when its component holds several bodies, else the component's. Imported bodies
show those names until you give one with `model.body_name`, which wins. To
convert an imported flat plate to sheet metal, load `steve-sheet-metal` (`sheet_convert`).

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