What Is LibreSpin and Why I'm Building It
The fragmented workflow
Every PCB design cycle I run at my day job goes through roughly the same sequence: someone shares an idea for a new product, I gather and write requirements, start researching/brainstorming architectures, come up with a block diagram, perform some calculations, open KiCad, build and simulate circuits, run ERC to catch electrical rule violations, fix them, start the PCB layout, run DRC to catch physical design violations, fix those, check for manufacturability issues, then export Gerbers, drill files, a BOM (bill of materials), and a pick-and-place file. Each step has its own mental overhead, its own failure modes, and its own set of well defined process steps and checklists.
Like most EEs, we do all of that manually, step-by-step, on every design, every time. And I’ve been thinking for a while that at least some of those steps are exactly the kind of mechanical, rule-following work that AI is getting genuinely good at.
LibreSpin is my attempt to build a harness for that. The idea is to orchestrate the full PCB design pipeline using AI: natural language requirements in, fabrication & assembly files out, with a human review step before anything actually goes to a fabricator. The goal isn’t to replace the human designer, but rather to augment and streamline. If you could snap your fingers and have 80% of the mundane design done for you so that you could spend your time working on the more interesting and challenging 20%, wouldn’t you?
The LibreSpin pipeline aims to do that:
- Natural language interviews led by AI to gather requirements, ideas, and target specifications
- Architecture review via web searching for multiple candidate designs
- Design validation against requirements to weed out the low-likelihood-of-success concepts
- Winning concept designs earn another AI web research pass to choose key components and a final concept design document is generated with block diagram (initial target is ASCII + drawio).
- Circuit calculation within CalcPad CE
- Schematic capture in KiCAD
- SPICE simulation with Ngspice CLI
- PCB layout in KiCAD
- ERC/DRC/DFM checks (electrical rules, design rules, and design for manufacturability)
- Fabrication/Assembly file export (Gerbers, drill files, BOM, pick-and-place)
Where the name came from
The Libre prefix comes from a naming convention with roots in projects like LibreOffice and LibrePCB, both of which use it to signal free and open-source software. I’m borrowing that convention intentionally, since LibreSpin is meant to be genuinely open from day one, not open-core or “free tier.”
Spin is EE slang for the full board design cycle. When an engineer says they’re spinning a board, they mean the complete loop from requirements to fabrication. One spin is one physical board. A second spin is the revision you do after the first board comes back and something doesn’t work. Most PCB designers are familiar with the term; it’s specific to a niche audience, albiet somewhat obtuse to those not in the field. That’s ok. because I think it captures exactly what the tool is meant to automate.
Why the FOSS EDA stack is actually the right foundation
KiCad is a capable, mature, open-source PCB design application. I use it daily and have built CLI automation around it, including scripts for ERC/DRC validation and production file export that have meaningfully reduced the overhead of my own design cycles. Ngspice, which ships embedded in KiCad, is a capable circuit simulator. The tools themselves are not the problem.
The problem is that nothing holds the entire design pipeline together. There’s no harness that takes a requirements description, coordinates the calculation and simulation steps, drives the schematic/PCB capture, checks the rules, and produces the output files as a single flow. Proprietary EDA tools from Cadence, Altium, and Mentor have invested heavily in tighter integration within their own ecosystems, but those tools are expensive and closed, and they’re still not doing what I’m describing here.
Currently, the PCB design workflow from beginning to end is strung together by human intelligence, wisdom, experience, and reasoning. LibreSpin aims to compress those development timelines without replacing humans. Human-lead design is a core tennet of LibreSpin.
How I’m building it, and why these tools specifically
I’ve been building software with Claude Code as my primary collaborator for roughly the past year. Most of that work has been engineering tooling: CLI automation, design validation scripts, a parts inventory system, diagnostic tools, and so on. The pattern I’ve seen consistently is that Claude Code handles tasks well when the problem is very well-specified, success criteria are known and can be used for benchmarking, the outputs are deterministic, and artifacts are testable. This is exactly what a PCB design pipeline is.
LibreSpin is implemented as a Claude Code plugin of various skills that all act as a harness to deliver what I described above. While Claude Code does interact with Anthropic’s servers, the applications that Claude interfaces with run locally on my own machine: KiCad for schematic and layout, Ngspice command-line integration for simulation, CalcPad CE for the circuit math, and so on. Given that the harness is primarily just markdown files, I suspect it would be trivial to shoe-horn this project into one of any other LLM coding platforms. The project is MIT licensed, so feel free to make as much money as you want with it.
One thing I want to be upfront about: KiCad, CalcPad, and Ngspice are initial targets. While I suspect they will remain my tools of choice for a long time, things can change. I chose them because they’re what I already use in my daily workflow, which means I understand the inputs, outputs, failure modes, and quirks at each step firsthand. The shortest path to a working prototype is to build a harness that replicates what I already do manually, using tools I already know, so I can actually tell when the AI is getting it right. If a major breaking change in any of these tools makes them impractical to support, or if something better comes along, the pipeline is designed to be modular enough to swap components out.
Where things stand right now
I’m not starting from scratch. I already have a working natural language to concept design step that generates structured design options from a plain English requirements description. This was an early attempt by me to test the feasibility of this idea over Christmas break. I plan to make this the first deliverable in the LibreSpin plugin. It won’t be very polished (yet), but it will give us a chance to play with it and for me to gather feedback.
The next post will go into the concept design step in more detail: what the prompt structure looks like, what the AI actually generates, and what I’m not sure about yet. After that, the plan is to document each stage of the pipeline as it develops, including the parts that don’t work on the first try.
The GitHub organization is at github.com/LibreSpin. Keep an eye out there for additional development updates.
Cover photo by Nic Wood via Pexels.
