Skip to content

Manufacturing as Code

Manufacturing as Code means defining physical designs (e.g. 3D models, CAD artifacts) with code instead of only with traditional GUI-based CAD tools. The same practices that work for software — version control, collaboration, automation, and reuse — then apply to manufacturing.

Why it matters

In traditional CAD workflows, designs live in proprietary files and tools. That leads to:

  • Weak version control — Hard to see what changed between revisions or which physical part came from which version.
  • Hard collaboration — Remixing or contributing to someone else’s design usually requires the same CAD software and manual re-export/re-upload.
  • Limited automation — Exporting variants, running builds, or deploying to a platform is mostly manual.
  • Customization friction — Parametric designs exist, but generating and publishing many parameterized variants is tedious and not scriptable.
  • Lack of portability — Designs are locked in proprietary formats tied to specific software; migrating to a different tool often means rebuilding from scratch.
  • Opaque to LLMs — Binary and proprietary CAD files can't be read or modified by AI assistants, so you miss out on using LLMs to help design, review, or iterate.

With code-defined designs, the source of truth is text (e.g. Python). You get:

  • Real version control — Diffs, branches, and tags like any codebase; artifacts can be tied to commits.
  • Collaboration like open source — Fork, change, and propose updates via pull requests; review and merge.
  • Automation — CI can build models, run tests, and publish artifacts on push.
  • Parameterized and semi-custom parts — Functions and parameters define variants; automation can build and publish them.
  • LLM friendly — Code is easy to understand and modify with LLMs, unlike traditional GUI-based CAD tools.
  • Self-documenting — Comments and meaningful names can explain design intent directly in the source, something hard to do in GUI-based CAD files.

By building CAD models as code, it becomes much similar to software development. We can now iterate the design process much faster and more efficiently with fellow engineers and AI assistants.

Preserving manufacturing knowledge

Manufacturing is knowledge-intensive; that knowledge can be lost if it’s only in people’s heads or in closed tools. Code is:

  • Portable — Not locked to one vendor or product.
  • Readable and auditable — You can see exactly how a part is defined.
  • Long-lived — As long as we can run the language (e.g. Python) and the libraries (e.g. Build123D), we can recreate the design.

Defining manufacturing in code helps preserve that knowledge in a form that’s easy to backup, share, and run in the future.

Build123D and MakerRepo

Build123D is a free, open-source way to create 3D CAD models in Python. You write code; the library produces 3D geometry. MakerRepo builds on this by:

  • Hosting your Build123D (and related) code in Git repositories.
  • Running CI to build models and collect artifacts.
  • Serving those artifacts on MakerRepo.com with a web viewer.

So you get “manufacturing as code” in practice: code in Git, automated builds, and published artifacts you can view and share.

Further reading

For a longer narrative on pain points, the future of semi-customized manufacturing, and the motivation behind MakerRepo, see:

Manufacturing as Code is the Future, and the Future is Now — Fang-Pen Lin (Jan 2026)