text-to-cad: The Open-Source Plugin That Gives Claude Code and Codex CAD Skills

text-to-cad is the open-source plugin that gives a coding agent the ability to design physical parts. Installed into Claude Code, Codex, Cursor, Gemini or Grok, it lets the agent write STEP, STL, 3MF and GLB files from a plain-language request, check the result for manufacturability, draw it, and prepare it for a printer or a sheet-metal shop. The GitHub repository is MIT licensed, sits at about 19.3k stars and 1.9k forks, and was one of the fastest risers on GitHub's trending list this week with roughly 2,500 stars gained in seven days.

The reason it matters for builders: until now, "AI writes my CAD" mostly meant a one-shot web demo that produced a mesh you could not edit. This project takes the opposite route. The agent writes parametric code, a real geometry kernel builds the solid, and the output is a standard STEP file any CAD package can open. That fits the pattern we have covered in the agent skills guide: a skill is a set of instructions plus tooling that turns a general agent into a specialist.

TL;DR

What does text-to-cad actually give an agent?

According to the README, the plugin gives "your agent local workflows for generating 3D models as STEP, GLB, STL or 3MF files," and it "also does design for manufacturing checks, generates engineering drawings, and connects to popular 3D printing, sheet metal and CNC fabrication services."

Agent skills library shelf with one skill card pulled out, illustrating the text-to-cad skill set

The repository ships these skills, each in its own folder under skills/:

That is a full chain from idea to physical object: describe a part, build the solid, check it, draw it, slice it, print it. Nothing in that chain is a hosted API; the README stresses that the skills run locally.

How do I install text-to-cad?

The project's recommended route is to let the agent do it. Send this message to your agent:

Install text-to-cad from https://github.com/earthtojake/text-to-cad

If you prefer to do it yourself, you need uv first, because every skill runs the cadgen tool through it. Check with uv --version. Then, per agent:

Claude Code

claude plugin marketplace add earthtojake/text-to-cad#latest
claude plugin install text-to-cad@earthtojake

Restart the app. The plugin also starts CAD's local server, and where Claude Code can show app views, models appear as viewer cards in the conversation. In a plain terminal, asking for a model gives you a link that opens it in the CAD Viewer in your browser. For general plugin background, see our Claude Code mods and plugins guide.

Codex

codex plugin marketplace add earthtojake/text-to-cad --ref latest
codex plugin add text-to-cad@earthtojake

In the Codex app the plugin adds a CAD tab beside each thread. Codex plugins are covered in our Codex plugins repository explainer.

Cursor, Grok Build, Gemini, other agents

Cursor and Grok Build also load the Claude Code plugin if it is already installed. Gemini installs it as an extension with gemini extensions install https://github.com/earthtojake/text-to-cad --ref latest --consent --auto-update. For anything else, npx skills add earthtojake/text-to-cad#latest installs the skills alone.

One warning from the README worth repeating: install the plugin or the skills in a given app, not both, "two copies means every skill twice."

Updates follow the same path. The README notes that npx skills update only refreshes skills already in your lockfile, so it silently misses new ones; re-running the add command is the reliable way to pick up new skills.

What are people going to ask about it?

How is this different from other text-to-3D tools?

Most text-to-3D generators produce a mesh, a bag of triangles that looks right but has no dimensions, holes you can parameterize, or feature history. text-to-cad's main output is STEP, a boundary-representation format engineers use for machining and assembly. The agent writes code, the OCP geometry kernel builds the solid, and a change request ("make the wall 3 mm thicker") is an edit to code, not a new generation. That is the same property that made Blender MCP workflows useful for blockouts: the model drives a deterministic tool instead of imagining pixels.

Does it run locally or in the cloud?

Locally. The CAD runtime is downloaded once through uv and then works offline: the README says "Offline, nothing is sent and everything works." The only network calls are the optional telemetry and a once-a-day version check to api.texttocad.dev/v1/versions, which can be disabled with CADGEN_UPDATE_CHECK=0.

What about telemetry?

It is on by default. The README says the app, viewer and build daemon send usage statistics tagged with a random install ID: versions, install source, OS and agent app, counts of tool calls and failures (as fixed words, never messages), and how many models were built. Crash reports carry the error type and location in cadgen's code, never the message. Per the README it never includes file names, paths, contents or prompts, and the server adds only a country derived from the IP address, which it does not keep. Turn it off, which also deletes what was sent, with uvx cadgen telemetry off. Nothing is sent by default in CI or a development install.

Does it work on Windows?

Mostly, with one real trap. The CAD kernel behind the CAD, DXF, URDF, SRDF and SDF skills is OCP, OpenCascade's Python binding, and its wheel ships an unsigned native module. Windows 11's Smart App Control, on by default for fresh installs, blocks unsigned native code, so every cadgen command fails with ImportError: DLL load failed while importing OCP. The README says Smart App Control has no per-app exception: either turn it off (and note it can only be turned back on by reinstalling Windows) or run the skills under WSL. cadgen doctor names the problem when it detects it.

Why does it matter that robotics files are included?

The URDF, SRDF and SDF skills are the sleeper feature. Robot description files are tedious XML that agents routinely get subtly wrong: inertials that do not match meshes, joints without limits, collision rules that block valid motion. Having dedicated skills for them means a coding agent can go from a part to a robot model that MoveIt or a simulator can load.

Robotic gripper inside a glass dome, illustrating agent-generated robot description and simulation files in text-to-cad

Pair that with the STEP-parts finder, which pulls real screws, bearings and motors rather than inventing geometry, and you get something closer to an engineering assistant than a shape generator.

How good are the manufacturing checks?

The DFM skill is the part we would trust the most conceptually, because it is built around evidence rather than vibes. The README says it reviews a part for sheet metal, CNC machining or injection molding "with measured evidence and the cited rule behind every finding," and measures draft, undercuts and projected area from a mesh. The DfAM check measures wall thickness, overhangs, support volume and build orientation per print process.

Two reviewers inspecting a part, illustrating the DFM review step before manufacturing with a CAD agent

This is the same lesson as with code: an agent that generates and an agent that checks are better than one that only generates. It echoes the human-in-the-loop principles we have written about. Printing a 20-gram bracket is a cheap mistake. Ordering a laser-cut steel plate or machining a load-bearing part from an unreviewed AI model is not.

A practical first session

Try something small and verifiable:

Use the CAD skill to design a 60 x 40 x 25 mm project box with a 2 mm wall,
four M3 corner posts and a snap-fit lid. Export STEP and STL, then run the
DfAM check for FDM and report any overhangs over 45 degrees.

What to look for:

1. The agent should produce source code and a STEP file, not just a mesh.
2. Open the model in the CAD Viewer and verify the dimensions yourself.
3. Ask for the engineering drawing PDF and compare hole callouts with your intent.
4. Only then slice with the G-code skill and send to a printer.

If you already use skills heavily, notice how this slots in next to others we have covered, such as Matt Pocock's engineering skills for planning and TDD, and SwiftUI Pro for domain-specific review. The difference is that this one has a physical-world output.

Limits and honest caveats

• Accuracy is your job. The checks are measurements, not guarantees. Tolerances, fits, material choice and load paths still need an engineer.
• Pinned runtimes. Claude Desktop's config pins a cadgen release in args (the README example uses cadgen==0.7.21) and uvx keeps the version it first downloads, so you must bump it manually to update.
• Plugin or skills, not both. Double installs duplicate every skill and waste context tokens.
• Supply-chain hygiene. Plugins run code on your machine. Read what you install, pin versions where you can, and prefer the latest branch, which the README says holds only the plugin and gets each release once it is on PyPI, over main, where unreleased changes can land. Our MCP security explainer covers why that matters.
• Third-party services. The SendCutSend and Bambu Lab skills connect to external fabrication tools you must already use.

What this means for builders

CAD has been one of the stubborn domains for AI because geometry has to be exactly right. Wrapping a proven kernel (OpenCascade) in agent skills sidesteps the hard part, letting the model do what it is good at, writing structured code from intent, while the kernel does what it is good at. Expect more projects to follow the pattern: a skill library plus a local server, installable across Claude Code, Codex and Cursor from one repository. The Model Context Protocol guide explains the server half of that design.

For hobbyists it lowers the barrier to printing custom parts. For hardware startups it shortens the loop from idea to DFM feedback. For robotics teams it automates the boring description files. For everyone it is a reminder that the most useful agent plugins are the ones tied to a real tool with real checks.

Related reading

• What are agent skills? The complete guide
• What is MCP? The Model Context Protocol guide
• Claude Code mods and TypeScript plugins guide
• OpenAI Codex plugins repository explained
• Blender MCP blockout workflow
• Matt Pocock's agent skills for real engineers
• Human-in-the-loop AI: when to let the agent run
• Official: text-to-cad on GitHub, texttocad.dev, uv documentation

Star counts, versions and install commands are accurate as of October 12, 2026 and may change; check the repository README for current instructions.