AI coding tools are getting much better at writing real software. They can read a codebase, pick useful abstractions, call tools, and iterate toward working outcomes. What has been missing is an equivalent interface for CAD.
That is the direction CADbuildr is pushing toward.
CADbuildr's foundation library gives CAD a programmable surface: an open-source, API-first CAD library designed to make geometry accessible as code. It is being built to stay as kernel-agnostic as possible over time. OpenCascade is the first kernel supported today, and the broader direction is to support multiple kernels and make it easier to target platforms engineers already use, including Onshape, SolidWorks, Autodesk, Fusion 360, and others.
On top of that, the new cadbuildr-ai-plugin repository packages the skills and MCP configuration needed to make CADbuildr usable from agent-first coding environments like Claude Code, Cursor, Codex, and Mistral Vibe.
The point is not just to let an LLM generate a shape. The point is to give agents a way to work with CAD as structured, executable, revisable code.
Vibe-CADing is not about replacing engineering judgment. It is about giving agents a programmable CAD interface so design loops can be faster, more iterative, and easier to automate responsibly.
Over the last year, the center of gravity in developer tooling has moved from autocomplete to agents. Models can now work across codebases, choose tools, and take action instead of just suggesting the next line.
That shift matters for CAD, because CAD has historically been one of the least accessible domains for automation.
Most CAD systems are still built around direct manipulation in a UI, proprietary file formats, and workflows that are difficult for an agent to reason about. Language models are strongest when they can operate over code, APIs, and composable abstractions.
That is why CADbuildr matters here. foundation is already a Python API for creating 3D objects. The plugin repo adds the missing layer for agent-native workflows: instructions, skill packaging, and MCP configuration that make CADbuildr discoverable and usable inside modern coding agents.
Agents are getting good at writing code, and we are giving them the right interface to write CAD code too.
cadbuildr-ai-plugin repo doesThe cadbuildr-ai-plugin repo is a distribution layer for CADbuildr in agent environments.
A good agent integration is rarely just "here is an API." In practice, successful integrations combine:
That is what this repo does for CADbuildr.
It packages the skills and MCP configuration needed to expose CADbuildr cleanly to tools like Claude Code, Cursor, Codex, and Mistral Vibe. Instead of forcing each user to wire everything from scratch, it provides a reusable structure that points agents at CADbuildr with the right context and workflows already in place.
The deeper story sits below the plugin itself.
foundation is the backbone: the library that gives CADbuildr its programmable interface. Instead of treating CAD as an opaque file or a sequence of UI actions, it lets you define geometry as code.
That model matches how coding agents already work.
Agents do not need to understand geometry the way a CAD power user does in a traditional GUI. They need a programmatic representation they can inspect, generate, modify, and rerun. A Python CAD API gives them exactly that.
Instead of operating on a binary artifact, they can write code, call tools, review outputs, and refine results the same way they already do for the rest of the software stack.
That is the core idea behind what we call Vibe-CADing.
Not because CAD should be sloppy or improvised, but because the interaction model is changing: you describe intent, the agent writes or edits CAD code, and then you iterate. The work moves from manual geometry construction toward guided program synthesis.
The workflow starts with a CADbuildr project and a configured API key. From there, the plugin can be used in agent environments including Claude Code, Cursor, Codex, and Mistral Vibe.
Go to hub.cadbuildr.com/settings and create a new API key.
Quick setup for the current terminal session:
export CADBUILDR_API_KEY="your_api_key"
echo $CADBUILDR_API_KEY
Persistent setup for zsh (recommended if you use Claude often):
echo 'export CADBUILDR_API_KEY="your_api_key"' >> ~/.zshrc
source ~/.zshrc
Keep this key private and never commit it to git.
A typical flow:
Start Claude Code first (from your project directory):
claudeThen run the following inside the Claude chat session:
/plugin marketplace add cadbuildr/cadbuildr-ai-plugin
/plugin install cadbuildr@cadbuildr-ai-plugin
/reload-plugins
That is the thin end of the wedge. Once this is working, the interaction changes from "please write speculative CAD code" to "use available CADbuildr workflows to build the part I want."
The same principle carries to other agent environments: configuration details differ, but the model should always get a clean, reusable interface rather than raw prompting alone.
The near-term direction is clear:
The broader technical direction matters too. If CADbuildr stays kernel-agnostic, supports multiple backends, and connects naturally to the platforms engineers already use, then agent interfaces become much more powerful.
Instead of being tied to one kernel or one output path, CAD code can become a higher-level representation that travels across tools and environments.
CADbuildr foundation provides the programmable CAD layer.
cadbuildr-ai-plugin makes that layer usable from today's agent environments.