Build hardware with AI

Build hardware with AI, and know it works before you order.

An AI coding agent can draw a schematic, route a board, model an enclosure and write the firmware. What it cannot do on its own is tell you whether the thing works. Nihil is the desktop IDE that hands your agent a circuit simulator, a digital twin and four gates, so a hardware project goes from a sentence to fab-ready files with the proof attached.

14steps from a declared board to its fab set, the same for every board

4gates an agent cannot talk its way past

19chip models your firmware runs on before the board exists

0models hosted, tokens resold: the AI is the one you already use

What AI can build today

The design step is real. In November 2026 Anthropic published a test of Claude on electronics design: with Diode, Claude designed a speakerphone, a voice-assistant hub and a handheld virtual pet, and Diode manufactured all three boards directly from Claude’s design files. Claude Code can drive KiCad through an MCP server, as JLCPCB’s walkthrough shows.

The step after it is the open one. That same Anthropic write-up says its devices are still prototypes that have not been through electrical validation, antenna tuning, thermal testing or certification, and lists checking designs in simulation among the things to try next. JLCPCB’s walkthrough says the result still needs engineering verification. Everyone who has done it says the same thing: an agent that can make a board is not an agent that knows the board is right.

Nihil is built for that second half. It covers the electrical and thermal questions in simulation, with your firmware running, before anything is ordered. It does not tune antennas and it does not certify anything.

From a sentence to a board, step by step

This is what building a product with an AI agent looks like inside Nihil. The agent does the work through one MCP server, nihil, with 34 tools. You pair with it on every decision, hand it the whole job, or anything between.

  1. Say what you want. A new project opens with an interview: 56 questions in 9 topics, one at a time, from the mechanics to how you like to work. Every question explains itself, and one card answers all of them with the recommended choice if you would rather not.
  2. The agent writes the board as a script. A Python generator declares every part with its datasheet pin table, then the nets, the outline, the placement and the pours. Parts come from a library of 113 common ones in 15 categories, each resolved live to a part number at the distributor. Nobody draws, and nobody edits the KiCad file by hand.
  3. The circuit runs before KiCad opens. Step 2 of 14 is the first gate: the board’s scenarios run in a transient circuit simulator under eight stress rules. A regulator past its rating fails here, while fixing it is one line.
  4. Schematic, placement, routing, pours. The pipeline writes them and checks them: ERC at step 5, the final DRC with parity at step 12 along with the circuit again on the routed copper, and a live check of every purchased part at step 13.
  5. The firmware runs on the board that does not exist yet. The agent writes the control code in portable C. It compiles for the microcontroller and for your PC, and the PC build runs on a chip model whose pins are nodes in the solved circuit. How firmware runs before the PCB.
  6. The product runs in a twin. The same firmware drives a physics model of the whole thing at a fixed 1 ms tick: on the demo’s RC car, the tyres, the motor, the battery pack and the walls.
  7. The enclosure is a script too. One parametric CadQuery script per assembly, with STEP and STL out. From that CAD and the harness data Nihil works out a build guide: the demo’s RC car comes to 70 steps, 276 parts and 10 tools.
  8. Four clean gates, then the fab set. Gerbers, the bill of materials, the placement file and a STEP model exist only when the circuit stress gate, ERC, the final DRC and the part check are all clean. The verdict is two words: nihil obstat, nothing stands in the way.
  9. Then the real one. You order the boards, you build it, and the bench has the last word. A scenario that passed in the twin is meant to run on the hardware unchanged.
The Interview in Nihil's Atlas space: nine topics down the side from Start to How the owner likes to work, 56 questions open, a card that offers to let Nihil pick every recommended answer, and the first question in focus, do you already have CAD or PCB files to bring in, with Starting fresh recommended.
Step one. The interview that starts a project, on its first question: bring in what you have, or start fresh. “I don’t know” is always an answer.

Why the gates matter more than the model

An agent is persuasive. It will tell you the board is fine in a confident paragraph, and it will be wrong some of the time. So nothing in Nihil takes its word. A scenario ends in accept lines such as accept min(+3V3) >= 3.20 after 0.005, and the engine that computed the number judges the line. The same inputs and the same seed give the same trace hash, so a pass can be run again by anyone. A check that did not run is not a pass.

That holds whichever AI you bring: Claude Code, Codex, Gemini, Antigravity, OpenRouter or a local model, in your own terminal inside the app, on your own plan. Nihil hosts no model and resells no tokens. What an AI agent gets for PCB design, tool by tool, and how agentic hardware design works, from one agent to a swarm.

The Sandbox on a recorded Full PCB run of the RC car, flown into the pwm_amp board: copper lit where current flows through the H-bridge and the opto-isolated input stage, the car_ctrl board beside it at Circuit fidelity, and a scope under the stage reading the motor current M1.i from the recording.
The demo’s RC car in a recorded run: the amplifier board solved on its real copper with the firmware driving, and a scope on the motor current. How the PCB simulation works, and where it stops.

One that was built this way

The demo project is an RC car: an ESP32-P4 controller board, an opto-isolated PWM amplifier board, a 6S battery pack, a gearmotor and four time-of-flight sensors, 150 parts and 73 nets across the two boards. Its firmware’s host suites report 2412 of 2412 checks. The same project shows a gate saying no: its PWM drive reads obstat, because in a 300-second soak at the hottest ambient one part’s case reached 60.98 °C against a 60 °C limit. The demo opens the whole project in a browser tab, read-only, in the real app.

The AI hardware tools, side by side

There are several good ways to build hardware with AI, and they are not the same product. Each row says what the tool is in its own words, as its site put it in November 2026.

Ways to build hardware with AI
ToolWhat it is, per its own siteReach for it whenWhere Nihil differs
Flux “Create Hardware with AI”: an idea turned into a schematic, a routed PCB and fab-ready files, in your browser. You want to design in a browser tab with nothing installed. Nihil is a desktop app on plain files in your own git. It takes the agent you already run, and it judges the board in simulation with its firmware running.
Quilter “Physics-driven AI that automates PCB placement and routing.” You want placement and routing automated. Nihil is not a layout specialist. Routing is one of its fourteen steps; the rest is the circuit, the firmware, the twin and the gates.
Diode “Custom circuit boards, designed and manufactured with AI”: you design with its AI agent, or its electrical engineers do. You want the board designed and made for you. Nihil makes nothing physical. It hands you the fab set, and you send it to the fab you choose.
tscircuit and atopile Circuits as code. tscircuit is “the framework for AI-generated electronics”, in React and TypeScript under the MIT licence; atopile’s line is “Hardware as code”. You want a board described in a language an agent already writes well. A Nihil board is code too, a Python generator. Around it sit the firmware in the loop, the twin, the gates and the record of every run.
KiCad MCP servers Ways to let an agent such as Claude Code read and edit a KiCad project, which the JLCPCB walkthrough says still needs engineering verification. You want an agent inside KiCad itself. Nihil’s agent edits the board and also runs the simulator and the gates, so the verdict comes from the engine.

These stack more than they compete. A KiCad project, wherever it came from, imports into Nihil directly, and then runs the same simulations and gates as a board born here. For the simulators themselves, see Nihil next to Wokwi, Renode and KiCad’s simulator.

Where building hardware with AI still stops

  • A person orders the boards, solders what the fab did not, and holds the probe. Nihil talks to a real board over a serial port, and that part is early: it has run on one ESP32-S3 dev board so far.
  • An agent can write a wrong scenario. The gates judge the scenarios you have, so read the accept lines the way you would read a test.
  • A pass is a model’s answer. Every constant only a bench can settle is listed as a BENCH row, and the result names the ones it leaned on.
  • No RF, no antenna tuning, no certification. Radiated emissions have a solver of their own that is not in the demo’s gates today.
  • Nineteen microcontrollers are modelled, not every chip. Arduino sketches and vendor SDK programs do not run in the loop yet.
  • The desktop app is in invite-only alpha.

Questions people ask

Can AI design a PCB?

Yes. A coding agent can declare the parts and nets, place and route the board and run the rule checks, and boards made that way have been manufactured and worked. What an agent cannot do by itself is know the board is right. In Nihil the agent writes the board as a Python generator, and no fab file exists until four gates are clean: circuit stress, ERC, the final DRC with parity and a live part check.

Can AI build hardware from a prompt?

It can take a described product to fab-ready files, firmware and a build guide. In Nihil a new project starts with an interview, then your agent designs the boards and the enclosure, writes the firmware and runs all of it in simulation. A person still orders the boards, assembles them and tests on the bench.

Which AI can I use to build hardware?

In Nihil, the one you already have: Claude Code, Codex, Gemini, Antigravity, OpenRouter or a local model, in your own terminal inside the app. Nihil hosts no model and resells no tokens. The agent reaches the pipeline, the simulators and the records through one MCP server with 34 tools.

Does the AI write the firmware too?

Yes. The agent writes the control code in portable C, and Nihil compiles it for the microcontroller and for your PC. The PC build runs on a chip model inside the circuit simulator and in the digital twin, before the board exists. Nineteen microcontrollers are modelled today, across Arduino AVR, ESP32, RP2040, RP2350, STM32, SAMD and Teensy 4.

How do I know the AI did not make it up?

The verdict never comes from the agent. Each scenario ends in accept lines that the simulation engine judges, the same inputs and seed give the same trace hash, and a check that did not run counts as not passed. Model constants cite a datasheet or a paper, and the ones only a bench can settle are listed as BENCH rows.

Do I need to know electronics?

It helps, and you can start without it. The interview explains every question and accepts “I don’t know”, the agent asks before it guesses, and the gates catch overstressed parts, rule violations and parts that do not exist. You still decide what the product must do, and the bench still has the last word.

Does it work with KiCad?

Yes. Nihil writes KiCad files, and a KiCad project you already have imports directly. For Altium, Eagle, a PDF schematic or a photo of a drawing, your agent writes the port and asks about anything it cannot read with confidence.

What do I have at the end?

For each board, Gerbers, a bill of materials, a placement file and a STEP model, written only after its four gates pass. For the product, the enclosure’s CAD, the firmware, a step-by-step build guide and the record of every run, as plain files in plain git.

Read next

See it run on a real board.

The demo project is an RC car, its two boards, its twin and every gate’s record, in the real app, read-only, in a tab. The desktop app is in invite-only alpha for Windows, macOS and Linux.