Diode Computers builds AI-native circuit-board design and manufacturing. Its open-source pcb toolchain lets you describe a board in Zener — a Python-like language for electronics — instead of dragging symbols around a GUI. Nets, components, and reusable modules become text you can diff, review, and version; the compiler turns that text into a KiCad layout and a checked bill of materials. It's the surface Anthropic partnered on to make Claude genuinely useful at electrical engineering.
Diode Computers, Inc. is a hardware company with a software thesis: a printed circuit board is a design problem that should be solved the way software is — in code, under version control, with automated checks and reusable parts. The company offers an end-to-end service (spec → design → fabrication) for teams building robotics, aerospace, edge-compute, and IoT hardware, and it does the design work on top of its own open tooling.
That tooling is the part most engineers will meet first. pcb is an open-source, MIT-licensed command-line suite built in Rust. It introduces Zener, a domain-specific language that extends Starlark (the Python-like config language Google created for Bazel) with PCB primitives — nets, components, modules, and interfaces. You write a board in .zen files; pcb validates it, resolves the parts, and generates a KiCad-compatible layout you can open and refine by hand.
KiCad and Altium are where you draw a board. Diode's Zener is where you write one — and then compile it down to KiCad. Same output format, a fundamentally different authoring model: hardware-as-code instead of hardware-as-drawing.
Software got version control, code review, package managers, and CI — and productivity compounded. Hardware design largely didn't. A schematic lives in a tool-specific binary file. Two engineers can't meaningfully merge changes. A code review is a screenshot. Reusing a known-good power supply means copy-pasting symbols and hoping you caught every net. The design is locked inside the GUI that drew it.
Code-defined PCB design breaks that open. When the board is text, a pull request shows exactly which two nets changed. A continuous-integration job runs electrical-rule checks on every push. A vetted regulator becomes an import, not a copy. And — the part that's suddenly load-bearing — a language model can read the design, reason about it, and write the next revision, the same way coding agents already work on software.
| GUI-drawn schematic | Code-defined (Zener) |
|---|---|
| Binary file, no meaningful diff | Plain-text .zen, line-by-line diff |
| Review = a screenshot in a meeting | Review = a pull request |
| Reuse = copy-paste symbols | Reuse = load() a module |
| Rule checks run manually, sometimes | pcb build in CI, every push |
| An LLM can't author it reliably | An LLM writes and edits it directly |
Zener gives you four primitives — nets (electrical connections), components (parts with footprints and pin maps), modules (hierarchical reusable subcircuits in .zen files), and interfaces (reusable connection patterns like SPI, I2C, or USB). You compose them in code; the compiler does the bookkeeping.
# blinky.zen — an MCU with a status LED load("@stdlib/interfaces.zen", "Power", "Ground") load("//parts/regulator.zen", "Regulator3V3") vbus = Power("VBUS") # 5V in from USB v3v3 = Power("3V3") gnd = Ground() # Reuse a vetted regulator block — one import, not a copy-paste Regulator3V3(vin = vbus, vout = v3v3, gnd = gnd) Component( name = "U2", mpn = "RP2040", footprint = "QFN-56", pins = { "VDD": v3v3.NET, "GND": gnd.NET, "GPIO25": Net("LED"), }, ) Component(name = "D1", mpn = "LED-0603", footprint = "0603", pins = { "A": Net("LED"), "K": gnd.NET })
The workflow is a handful of commands. pcb build validates the design and checks the bill of materials. pcb layout generates a .kicad_pcb file and opens it in KiCad, where you place and route — manual refinement stays in the loop. pcb fmt formats your .zen files (it uses ruff), and pcb sync reconciles imports against the dependency manifest. Projects are configured with a pcb.toml manifest, and a repo is either a board (one board plus local modules) or a registry (reusable packages, no board) — the npm-style split between an app and a library.
pcb is a Rust workspace of focused crates: pcb-zen runs the Starlark runtime and ships an LSP server and debugger support, pcb-zen-core is the language implementation, pcb-kicad parses and generates KiCad files, and pcb-layout drives layout generation. It targets KiCad 10.x, installs via a shell/PowerShell script or from source, and is MIT-licensed. Windows support is still flagged experimental — macOS and Linux are the well-trodden paths.
Anthropic partnered with Diode to improve Claude on a specialised task: turning a chip's datasheet into a working reference schematic. The reason that's even tractable is the same reason this leaf sits in our tree — once a circuit is code, generating one is a code-generation problem.
The collaboration focused on auto-generating reference designs: read the datasheet, understand the recommended configuration, and emit a correct Zener design. Early on, Claude struggled in the ways you'd expect — missing nuances buried in datasheet tables, misreading reference-schematic images, and misunderstanding the Zener DSL itself. The work targeted exactly those gaps, and Anthropic notes the resulting improvements are encoded in the publicly released models, so every Claude user benefits, not just Diode.
Diode evaluated the results the honest way — blind, by their own engineers, scored against testbenches that encode higher-level requirements rather than a rigid list of components. In that head-to-head, their engineers preferred Claude Sonnet 4.5's designs in 8 of 10 cases, ahead of both Claude Opus 4.1 and Claude Sonnet 4. The takeaway isn't a leaderboard number; it's that representing hardware as a structured language is what let a general model get measurably good at it.
Diode didn't make Claude better at hardware by bolting on a hardware plugin. It made hardware look like software — a typed, composable, text-based language with a compiler that gives fast feedback — and a coding-capable model met it there. That's the transferable lesson for any domain hoping agents will help: give the work a structured, checkable representation first. The model follows.
Our tech/embedded/platformio leaf covers the firmware for DroneScan's Hummingbird, Buffalo, and Meerkat units. That firmware runs on a physical board — an ESP32 or RP2040, a regulator, sensors, connectors. Diode is the layer below PlatformIO: it's where that board gets designed. Code-defined design means the hardware revision history lives in the same kind of git log as the firmware that runs on it.
When the Hummingbird and the Meerkat share a power tree and a comms front-end, that shared circuitry should be one reviewed Zener module imported into both boards — not two diverging copies in two binary schematic files. One fix to the regulator module propagates to every product that loads it, the same way a shared library does in software.
A new sensor or radio arrives with a 60-page datasheet and a recommended application circuit. The agent-assisted reference-design flow drafts a first-pass Zener schematic from that datasheet; an engineer reviews the pull request, fixes what's wrong, and runs pcb build. The slow part — transcribing a datasheet into a correct first schematic — gets compressed.
Code-defined PCB design is early, and it's not the right tool for every board or every team. Be honest about where it pays off and where the GUI still wins.
Local hardware teams carry a structural disadvantage: limited domestic PCB fabrication, long import lead times on components, and forex exposure on every order. The work that can stay onshore is the design work — and that's exactly the part code-defined tooling makes more portable. A Zener repository is a few kilobytes of text. It reviews over a video call, version-controls on the same GitHub a Johannesburg team already uses, and ships its Gerbers to a fab in Shenzhen or a board house abroad without anyone re-keying a netlist.
The open-source, MIT-licensed core matters here too. There's no per-seat Altium licence in dollars to justify before a small SA team can start designing seriously — KiCad plus pcb is a zero-licence-cost path from idea to manufacturable board. And because the design is text an LLM can author, a small team punches above its headcount: the reference-design grunt work that would otherwise need a senior hardware engineer gets a capable first draft from an agent, with the human doing review instead of transcription.
Diode is the bottom of the hardware stack — the physical board. It connects upward to the firmware that runs on it, sideways to the AI models that now help design it, and outward to the fab partners that turn a .zen file into a panel of boards.
The pcb repository is the fastest way to see Zener in practice. Anthropic's write-up is the primary source on the Claude partnership and the evaluation.