Why are so many startups developing PCB design tools?

Part 1: Diode, and connecting language models to the physical world.

I recently wrote a series of posts about different startups developing chip design tools. By leveraging AI technologies, and taking advantage of the boom in AI accelerator chips being developed, startups like Silimate and Primitive Instruments are building more powerful design tools for a growing customer base that desperately needs them.

At the same time, we’ve also seen a boom in the number of startups developing PCB design tools. Naively, it seems like the same explanation could apply -- but when you dig deeper, that’s not necessarily the case. While there are new applications for edge AI products, which may require many new PCBs to be designed, that doesn’t actually represent a huge increase in the total number of PCBs being designed. That’s because many, many PCBs get designed for all sorts of things, from children’s toys to spacecraft. What all of those PCBs have in common, though, is the inability to effectively design and test them quickly.

When you develop software, you can easily make mistakes and then fix them, because the time cost to recompile your program is usually negligible. When you design chips, mistakes can be hugely costly, so expensive and complex verification tools exist to ensure that you don’t make mistakes at all. PCBs are in an awkward in-between position; they’re relatively easy and low-cost to manufacture, but they can still have turnaround times measured in days or even weeks depending on the board’s complexity. Currently, PCBs mostly get tested manually, by manufacturing a board and seeing if it works. If it doesn’t work, the errors are fixed for the second manufacturing run.

Because of the relatively low cost and turnaround time, it didn’t make sense to deploy the same costly and complex verification tools used for chips to PCBs. However, with new AI technologies, there’s a new way to design PCBs that can solve this problem: designing PCBs that are correct by construction.

Over the next couple of weeks, I’m going to share the insights I got from talking to the founders of the companies building this new generation of tools. We’re going to start with the first difficult step in any PCB design process -- reading component datasheets and using that information to build schematics. Diode, founded by Davide Asnaghi and Lenny Khazan, is working to make that challenge a thing of the past.

Designing correct schematics is really hard.

If you want to design a PCB, you first need to select which components you’re going to be using in your design. Some of those components are straightforward, like resistors, capacitors, and voltage regulators. But some of those components can be fairly complicated. A microcontroller might have hundreds of pins, all of which have special rules. A buck-boost converter may require specific inductor values to properly output a stable voltage. And all of this information is written down in datasheets which can be formatted in all sorts of different, inconsistent ways.

Davide and Lenny, who’ve worked together at multiple medical device startups, know this problem all too well. Originally, as Lenny told me, they wanted to build a tool that would automatically verify the correctness of PCB schematics, using information extracted from component datasheets. But after about a month, they realized that they were going about it backwards. Existing schematics aren’t easy to verify, and Davide and Lenny were finding themselves extracting connectivity from schematic file formats that were designed to represent lines on a piece of paper.

But in doing this, they built a much richer representation of a schematic. This new representation is what’s enabling them to avoid building a verification tool and instead make boards that are correct by construction. And this new representation works by replacing circuit schematics with code.

With schematics-as-code, LLMs can start designing circuits.

Even if LLMs can read datasheets, it seems difficult to make an LLM output a circuit schematic. After all, a schematic is a bunch of symbols and lines connecting them, which is a far cry from the sorts of text outputs that LLMs are good at generating. As Davide told me, “the process of designing a circuit board is not very compatible with LLMs by default. So you really need to restrict the problem to something that the models are great at, which is text-to-text.”

Diode is solving this problem by leveraging “schematics as code”. Essentially, instead of representing your schematic as a bunch of lines and symbols, you represent your schematic as structured code that captures the connections between all of the components. The idea has been around for a while; Google had a version, there are multiple open source implementations, and there’s one being developed by the company JITX. Diode specifically is leveraging the atopile language for their internal schematics-as-code representation.

But on their own, these are piecemeal solutions, designed to replace the schematic editor with a code editor. Often, electrical engineers are reticent to adopt these solutions; they involve retraining a large human workforce that’s already familiar with schematic-based circuit design.

Diode, Davide says, is doing things differently. “We’re making opinionated choices about the hardware design style. Instead of handing you a loose set of tools, we are making a choice: this is what the user journey should be, from a system diagram to boards in your hands”.

In practice, this means that Diode has an LLM read a datasheet, and output schematics-as-code representing a reference design for that module. Then, a user can simply build their design out of pre-existing modules from Diode’s library. All a human needs to do is pick out which modules they want in their system.

What’s especially powerful about this approach is that each module can be essentially correct-by-construction. According to Davide, “the way we are thinking about building up the company is providing an IP library, that is pre-validated, where 90% of the generation work is done automatically.” Diode is able to leverage LLMs to generate a huge number of modules, and can validate them in various ways, including formal verification and test manufacturing runs. That way, an engineer using the Diode platform can feel comfortable knowing that whatever block they place in their design will work reliably the first time.

With new data and models, Diode gets better over time.

What makes Diode’s long-term vision particularly interesting, though, is how they can leverage improvements in LLMs to improve their component library, and how they can leverage their component library to improve their LLMs. Right now, they can have 80 or 90% of the generation work for their modules done automatically, with some human oversight, but new models may be able to do even more heavy lifting soon.

But also, as Davide and Lenny validate more and more modules, they’ll be sitting on a large and unique dataset of validated schematics represented as code. Davide hopes that “ideally, as time goes on, the block generation will become better and better to the point where most of the block design is done automatically, and a human only needs to glance it over”.

As somebody who’s spent many late nights with a soldering iron and a microscope debugging circuit boards, the idea of circuit boards that work the first time, every time, while also requiring much less work sounds far-fetched. But by leveraging schematics-as-code to build up a large repository of generated circuit modules, and leveraging that dataset to continuously improve their own LLMs, Diode may be able to make those late nights a thing of the past.