cad-skill: a Claude Code skill that prints parametric parts

A description in, a parametric script and an STL out

cad-skill is a Claude Code skill for generating parametric 3D printable models using CadQuery. The workflow it describes is the one in the readme: you describe a physical object, and Claude writes a parametric script, exports the STL, renders previews, and iterates with you until the result is right.

That last part, the iteration, is what makes it more than a prompt template. The examples in the repository are real objects that were designed this way. There is a MagSafe stand shown from four views, an iPhone 13 Pro case, a Gridfinity 3 by 2 bin for an Orico D110 label printer, a Gridfinity 3 by 3 bin for a Logitech MX Master 3, and a magnetic door catch shown from the frame side and the door side. Some of them were published on MakerWorld, which means they were printed.

The key property is that the output is parametric. What you get is a CadQuery script, not a mesh, so the model can be reopened and edited later, and the model is a description of the shape rather than a set of triangles. For anyone who has wanted to print a part and then change one dimension, that is the difference between a useful artefact and a dead end.

The skill was created by Nicolas Chourrout from Flowful.ai, and a long write-up on Medium describes the process of teaching Claude to design printable parts.

Installation is a clone into the skills directory

The install is short because the whole skill is a directory of files, including the workflow instructions.

mkdir -p ~/.claude/skills
git clone https://github.com/flowful-ai/cad-skill ~/.claude/skills/parametric-3d-printing

The destination directory name, parametric-3d-printing, is the name the skill is invoked by, and it is also the slash command you type.

Once installed, the skill activates in two ways inside Claude Code. The auto trigger fires when you describe a part you want to print, for example a wall mount for an Arduino Uno or a snap-fit lid for a box, and Claude picks the skill up from its trigger keywords, which are listed as 3D print, STL, CadQuery, enclosure, bracket and similar. The explicit slash command, /parametric-3d-printing, invokes it directly, which the documentation recommends when the request does not contain the obvious keywords.

After that, Claude walks through requirements, builds the model in phases of base shape, features and finish, and delivers an STL plus a rendered preview. That phase structure is a sensible decomposition for mechanical parts, where the base shape and the fillets and chamfers are different kinds of decision.

The dependency step is separate and has a hard constraint. The skill requires Python 3.10 to 3.12, because CadQuery's OCC kernel does not have wheels for 3.13 and later. The environment is set up like this:

python3.12 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

The Python version pin is not a style choice. If your system Python is 3.13, the install of the OpenCascade kernel will fail rather than degrade.

The scripts are the real deliverable

The file list in the readme is the clearest indication that this is a working toolkit rather than a collection of instructions, and the files are described one by one.

SKILL.md holds the skill definition and the workflow instructions for Claude, which is what the model actually reads. gridfinity.py is a tested Gridfinity bin generator covering the base profile, stacking lip, magnets, compartments and custom pockets, and it is vendored next to the generated scripts so a generated model can import it. outline_from_scan.py extracts a pocket outline from a 3D scan of an object, doing alignment, scaling, slicing and union, and produces something ready to hand to add_polygon_pocket.

preview.py is a headless STL to six-view PNG renderer built on trimesh and pyrender, with a --strict flag that fails on non-watertight meshes. That flag is the printability check in miniature, because a mesh that is not watertight will not slice or print reliably.

run_cadquery_model.py is the piece that makes the loop work. It is a subprocess wrapper that runs a CadQuery script, captures errors, optionally renders the preview, and emits a JSON result so Claude can self-correct in a loop. That JSON result is the mechanism: without a machine readable success or failure signal, the model has nothing to correct against.

The rest is utility work. mesh_io.py is STL loading with validation and no pyrender dependency, used by the wrapper and the converter. stl_to_3mf.py is a standalone STL to 3MF converter for Bambu Studio and PrusaSlicer, which is a practical detail since 3MF carries unit information that plain STL loses. design-review.md is a visual inspection checklist and printability analysis, and requirements.txt holds the pinned dependency versions.

The scan to pocket pipeline is the interesting part

One of the published examples deserves a closer look, because it shows the skill being used for something more than a shape someone imagined.

The MX Master 3 bin was printed and published on MakerWorld, and the readme describes it as a scan to pocket pipeline. The example script is examples/mx_master3_bin_3x3.py. The outline_from_scan.py script traces the mouse's real footprint from a 3D scan, the outline is then rotated to the angle that minimises its bounding square, so the bin fits a 3 by 3 grid instead of 4 by 3, and a tilted thumb scoop ramps under the thumb rest to lift the mouse out.

Every one of those three steps is a decision that a human would normally make by hand, and each of them is mechanical enough to be expressed as a script. The rotation in particular is the kind of thing that is obvious once you see it and nearly impossible to get right by describing in words, because the minimising angle depends on the scanned outline. Doing it as a rotation search over the traced outline is both faster and more repeatable.

The thumb scoop is the other end of the range. It is a deliberate ergonomic detail, a ramp that lifts the mouse out of the pocket rather than leaving it buried, and the fact that a language model produced a design decision of that kind and then printed it is the interesting result.

The Gridfinity base is the other recurring element, and it is where the vendored gridfinity.py pays off. Gridfinity is a bin standard, and a generator that reliably produces a correct base profile, stacking lip and magnet placement means the skill can focus on the part-specific geometry. That is the right division of labour for a tool like this, and the two example scripts, the D110 cradle and the MX Master 3 diagonal bin, both sit on top of it.

A noncommercial licence and pinned dependencies

Two facts about the project as a dependency deserve attention, and both are in the readme rather than buried.

The licence is the PolyForm Noncommercial License 1.0.0. The skill and the scripts are free to use, modify and distribute for noncommercial purposes, and the repository records the licence as one that GitHub cannot classify, with a LICENSE file at the root. The distinction from a standard open source licence is real: you can use it and change it and share it, but not for commercial purposes, and that is a restriction that most corporate open source policies will not accept without a conversation.

The dependency versions are pinned, and the reason is stated in requirements.txt itself. The pins are to the versions the skill was last tested against, and the comment says to bump deliberately and re-run all example scripts and previews if you upgrade. The ranges are cadquery 2.6.1 or later but below 3, trimesh 4 or later but below 5, pyrender 0.1.45 or later but below 0.2, Pillow 10 or later but below 13, numpy 1.24 or later but below 3, and lxml 4.9 or later but below 7.

That is the sensible policy for a skill whose output depends on a geometry kernel. A CadQuery major version can change what a boolean operation produces, and the only way to know is to regenerate every example and look at the previews. The tests/ directory at the repository root and the examples/ directory both exist for that purpose.

The maintenance picture is modest. The repository is not archived, the default branch is main, the last push was on 2026-07-14, more than three months before the current date, and there are no GitHub releases, so the skill is installed from the branch rather than from a version.

Editorial conclusion

cad-skill suits someone who wants to describe a bracket or a bin in words and get a printable parametric file rather than a one-off mesh, and it suits a maker who wants the model to stay editable after it is generated. It does not suit commercial use, because the licence is PolyForm Noncommercial 1.0.0, and it does not suit a team without CadQuery available, since the OCC kernel has no wheels for Python 3.13 and later. Before installing it, read SKILL.md, check the pinned dependency versions in requirements.txt, and decide whether a noncommercial licence is acceptable for what you plan to make.

Frequently asked questions

Official sources

1. flowful-ai/cad-skill on GitHub
2. Issues
3. README