Between Noodles and Wires: How AI is Democratizing Hardware Design
As children, many of us enjoyed taking apart and reassembling electronics, right?
Until 2020, I assumed the path to building my own physical products belonged to people with traditional STEM credentials. So, I focused on software and UX. During my bachelor's at The Hague University, an HCI course rekindled that excitement with an Arduino starter kit. I quickly swapped it for an ESP32, which led to Flasq and a smart bicycle bell for your office. But like so many side projects, they remained trapped in the "low-fidelity" breadboard phase — a tangle of jumper wires that never became a real product.
Co-created with AIAbout this imageThis image was co-created with the help of generative AI, with human direction and curation. It is labelled to be transparent about AI-assisted content, in line with the EU AI Act's transparency obligations.Learn more
The push I needed to cross that gap happened in a hostel in Shenzhen. I met a guy working on a custom PCB for an electric bicycle. Over cold bottles of 華洋 tangerine soda and bowls of noodles, he introduced me to the local hardware scene and actively encouraged me to dive down the rabbit hole.
Over the last few weeks, I've been rebuilding Flasq as a production-grade board, relying heavily on LLMs to break through the hardware barrier. But getting there required fundamentally changing how I interacted with the models.
Recently, I came across a Reddit thread asking a question that felt painfully familiar:
"Can Claude make a PCB for someone who doesn't really know what they're doing?"
The consensus was predictable: Yes, but it's an expensive way to learn, it struggles with complex board layouts, and you can't just blindly say "build me a custom radio" and expect a working Gerber file. Reading those warnings was surreal — I only saw the thread after living through that exact trial-and-error cycle back in July, at a time when I didn't even know what a Gerber file was.
The Limits of Vision and Library Traps
Emerging platforms like atopile.io and Flux.ai are doing incredible work to automate the hardware stack. Flux, for instance, can generate entire boards from scratch. But full automation introduces the classic black-box problem: when the AI builds everything behind a curtain and something fails, you have no mental model to diagnose why.
So, I tried collaborating step-by-step. My first prototype was still an outright failure. The Reddit skeptics were right about one thing: you cannot just throw screenshots at an LLM and expect a reliable design review. A vision model looking at a rendered board missed that my power traces were hopelessly thin.
Worse, an image couldn't expose a fatal footprint mismatch in my local KiCad library. My local install only had the footprint for an ESP32-S2 Mini, but I had selected an ESP32-S3 Mini from the manufacturer's catalog. The result was an S3 physically soldered onto an incompatible S2 pinout. Because the physical pad spacing lined up, it miraculously passed JLCPCB's automated DFM checks — and arrived completely bricked.
Feeding the Raw Data
The breakthrough came when I stopped treating the AI as an image inspector and started feeding it raw KiCad design files.
KiCad schematic (.kicad_sch) and board layout (.kicad_pcb) files are structured, human-readable S-expressions. The moment an LLM parses the underlying data tree rather than a compressed JPEG, its utility transforms. Instead of guessing based on pixel colors, it systematically parsed netlists, flagged pin mismatches, and caught missing bypass capacitors. More importantly, it explained why specific design choices mattered, turning late-night debugging into an accelerated masterclass on routing and grounding.
It also solved the most intimidating hurdle for a solo maker: component sourcing for PCBA. There is a massive practical divide between ordering a bare PCB and ordering an assembled board (PCBA). With bare boards, you have to hand-solder tiny surface-mount components yourself — a slow, high-friction process requiring a proper workbench. Turn-key PCBA, however, requires linking your design directly to the manufacturer's active warehouse catalog. The LLM bridged that gap effortlessly, mapping my schematic pins to in-stock LCSC part numbers so the boards would roll off the line fully assembled.
The second prototype booted straight out of the box. And because the models already understood the complete electrical schematic from the design phase, writing the initial firmware in VS Code took minutes — requiring only minimal pin alignment and zero guesswork.
Prototyping on the Road
I had always assumed hardware design was incompatible with a nomadic lifestyle. A hardware lab doesn't fit in a backpack, and there is no "WeWork for makers."
Pairing an LLM with modern fast-turn fabrication flips that constraint entirely. Prototyping on the road became a fluid loop: reviewing an AI's critique of a circular LED layout from a hostel bed, sending Gerbers off to Zhuhai for surface-mount assembly, picking up the finished boards, and flashing firmware over USB-C at a café table.
The Age of Personalized Hardware
We are entering a transformative era for physical computing.
On one end of the spectrum, projects like GainSec/AutoProber are combining vision models with CNC mechanics to autonomously probe and debug physical prototype boards. On the other end, the barrier between software and hardware is dissolving. As the team at Geastack noted in The Age of Personalized Hardware Is Coming, cheap edge silicon and intelligent developer tools are redefining who gets to build electronics. You no longer need a decade of embedded pedigree just to put your own device out into the world.
AI will not magically generate a flawless, production-ready board from a casual single prompt. But if you move past screenshots, feed it raw design data, and put in the work to learn the tooling, it becomes a remarkably patient copilot — guiding you through the daunting art of hardware engineering until you are holding a finished board in your hands.
What hardware ideas do you still have stuck in the breadboard phase?