cadquery-modeling

claude-cad

Make Claude Code verify its CAD parts — not just print [OK].

You ask an AI for a hollow enclosure. The script prints [OK], the STL preview looks exactly right — and the exported part is a solid brick. The .shell() silently did nothing: 158,048 mm³ of material where 2.5 mm walls should leave 33,370. Nothing raised, nothing warned, and from outside the two parts are identical.

Don't count on CAD to catch it, either. In our test, a provably invalid solid — claiming 51,185 mm³ inside a 32,000 mm³ bounding box — opened in SolidWorks with no dialog and no import diagnostics (the record). Bad geometry doesn't announce itself — not in the [OK], not in the STL, not always in CAD. What catches this brick is a volume that doesn't match what the dimensions predict; what catches a port cut into the wrong wall is a point that should be inside the plastic and isn't.

claude-cad is a Claude Code skill — a folder of instructions Claude Code loads automatically from .claude/skills/ when you open a project, so its rules are active with no install step (you confirm it loaded by typing /skills). Those instructions tell Claude Code to write the checks below into every part it builds and to treat a failing check as a stop, not an export — a rule the model follows, like the rest of the skill:

  claude-cad diagnostic report
  IsValid     : True
  solids      : 1
  volume      : 32163.55 mm^3
  bbox (XYZ)  : 94.00 x 65.00 x 27.20 mm
  RESULT: PASS — validity, single-body, volume, bbox verified;
          safe to export as a valid single solid
  claude-cad — checks applied

Who it's for — all three assume you're comfortable working in a terminal:

• New to CAD. You're comfortable with a terminal but you don't write CAD. Describe the part in plain English and the skill writes the CadQuery (Python parametric-CAD), asking about missing dimensions instead of inventing them. You answer the occasional dimension question and read a few numbers to check the result — no modeling software to learn.
• You want STEP, not mesh. Most AI-CAD emits STL — a fixed triangle mesh, fine to print but hard to change. You get STEP: a real solid that imports into SolidWorks or Fusion as geometry you can modify (an imported solid you can cut, fillet, and measure — not a native feature history, but far more than a mesh).
• You already model. This is the verification block you'd otherwise hand-write for every part, plus a re-tested record of the OpenCASCADE (OCC) kernel operations that corrupt silently (OCC is the geometry kernel under CadQuery).

The clone is the workspace — the skill ships inside the repo, already active. Commands below are Windows (PowerShell); on macOS/Linux use python3.11 in place of py -3.11 (SolidWorks itself is Windows-only, but the modeling and verification are cross-platform):

mkdir C:\dev; cd C:\dev            # a plain path, NOT OneDrive/Desktop/Documents (breaks SolidWorks later); skip mkdir if it exists
git clone https://github.com/0oKevino0/claude-cad.git
cd claude-cad
py -3.11 -m pip install cadquery   # Python 3.11 (newer Pythons lack the OCP binding); downloads ~300 MB

Open the folder in VS Code, open Claude Code, describe a part — QUICKSTART.md walks it end-to-end in ~10 minutes (longer if you still need to install Python or Claude Code).

What it checks

The skill has Claude Code end every part with a block like this and treat a failure as a reason to fix the part, not export it:

from OCP.BRepCheck import BRepCheck_Analyzer
from diagnose import assert_points               # the skill's point-classifier
solid = part.val()

# Valid B-rep, exactly one body — true or raise:
assert BRepCheck_Analyzer(solid.wrapped).IsValid(), "invalid geometry"
assert len(solid.Solids()) == 1, "expected exactly one solid"

# Volume against a range DERIVED from the dimensions of a 94×65×26 enclosure blank
# with 2.5 mm walls — the shape behind the intro's numbers. The expression is the
# check; nothing is measured off the built result and pasted back. (The shipped
# part in the report above adds a lid lip and internal features, so it measures a
# bit less — 32,163 — and stands 27.2 mm tall; a derived range absorbs that.)
L, W, H, t = 94, 65, 26, 2.5
expected = L*W*H - (L - 2*t)*(W - 2*t)*(H - t)   # solid block minus the cavity ≈ 33,370
assert 0.85*expected <= solid.Volume() <= 1.15*expected, "hollow/cut did nothing?"

# The strongest check — features where you MEANT them, not just the right bulk.
# This is what caught a port cut into the wrong wall in the worked example.
# (Coords below assume this enclosure is modelled from its footprint centre.)
assert_points(part,
    inside=[(46, 20, 13)],     # a point inside the +X wall — must be solid
    outside=[(0, 0, 13)])      # a point in the open cavity — must be hollow

Order matters. IsValid and the solid count say it's a clean solid; assert_points is what says it's the solid you asked for — bulk and bounding box can be right while a feature sits on the wrong face (see the worked example). Volume is the weakest of the four: a derived range, wide on purpose, to catch the gross failure — the un-hollowed brick reads ~158,000 mm³ where the walls should leave ~33,000 (Pitfall 4b) — not to certify a part correct to 2%. When a part fails, the report names the problem and the pitfall it matches, and whether it was safely auto-repaired.

Around the checks sit the rules that make them meaningful: the OCC kernel operations with a history of silent corruption — every claim re-tested against the current kernel, each with a Verified behaviour record — and the safe patterns that replace them. See docs/verification.md and docs/occ_pitfalls.md.

What you need

What's in the repo

Worked example

A single-board-computer case bottom shell — standoffs, vent slots, port cut-outs, screw bosses — described to Claude Code in plain English and verified before export. The full project, prompts, and verification record: examples/sbc-case/.

Scope & status

claude-cad is deliberately small: a verification-first workflow for CadQuery → STEP → SolidWorks, not a general AI-CAD