---
title: Can Circuit Design Be One Click? Giving an AI a Plain-Words Requirement, Verifying It in a Simulator, and Placing It on the Smallest Breadboard
url: https://oosioo.com/en/p/%EC%A0%84%EC%9E%90-%ED%9A%8C%EB%A1%9C%EB%8F%84-%EB%94%B8%EA%B9%8D%EC%9D%B4-%EB%90%A0%EA%B9%8C
date: 2026-10-20T09:54:59+00:00
author: SYSOP
summary: Circuit tools like PSpice are powerful once you know them, but they ask for circuit knowledge and software skills first. Could circuits work like vibe coding, where you describe the feature and get a design? I traced 65 years from the 1961 maze algorithm and 1973 SPICE to 2026's AI design agents, then had an AI design a door chime and a treadmill belt speedometer that run on a 9V battery. An automatic verifier (pin checks, ngspice worst cases, a virtual microcontroller) judged each design, and the ones that passed were placed automatically on a 170-hole mini breadboard with a bill of materials and a quote.
---
# Can Circuit Design Be One Click? Giving an AI a Plain-Words Requirement, Verifying It in a Simulator, and Placing It on the Smallest Breadboard

![Two circuits that an AI designed and that passed the checker, placed automatically on 170-hole mini breadboards. On the left is the treadmill belt speedometer: an ATtiny85 microcontroller, a regulator, a crystal and capacitors are plugged in, and a 9V battery, a reflective sensor and a 4-digit display are connected by wires. The display shows 10.0 km/h. On the right is the door-open chime, with only a buzzer, a MOSFET, two resistors, a capacitor and a diode. A black box at the bottom right lists, with check marks, "a few lines of requirements → AI design, pin and connection checks, SPICE worst case, firmware on a virtual chip, automatic placement on a 170-hole breadboard"](/uploads/04f62b766214bd7b.webp)

Circuit design programs such as PSpice compute how voltages and currents change over time once you draw a circuit, and they place parts on a small board and route the traces too. Used well, they tell you whether a circuit works without a single solder joint. The problem is "used well". You have to know how a transistor turns on and when a capacitor charges and discharges before you can draw the circuit, and you have to know the program's menus before you can run a simulation.

Code, meanwhile, is already written in words. Describe the feature you want, and the AI writes the code and checks it against the tests. Could circuits work the same way? Say "I want to measure how fast my treadmill belt actually runs, on a 9V battery" or "I'd like a sound when the door opens", and a circuit comes out. For something a little more complex, the AI reads public IC datasheets and produces a parts list and a quote you can order from right away.

In this episode I tried it to see how far that goes.

## What I set out to do

1. Lay out how circuit design moved onto computers: simulators, automatic routing, circuits written as code, and today's AI. Figures come from primary sources, and figures a company published about itself are marked as such.
2. Spell out what "designing" a circuit and "verifying" it each actually check.
3. Hand two examples to an AI for real: a **door-open chime** and a **treadmill belt speedometer**. Both run on a single 9V battery. The AI gets only requirements written in words and a list of parts it may use.
4. Before any person looks at the AI's design, an **automatic checker** examines it first. If it fails, the report goes straight back to the AI.
5. Place the circuits that pass onto the **smallest breadboard** that fits, automatically, and produce a parts list and a quote.

The research went to an AI agent. It was told to use only papers, patents, datasheets and official company announcements as sources, and to mark any year it could not confirm as unconfirmed.

## 65 years on one page

![A timeline of 65 years of circuit design automation. The gray band (1961–1993), "people draw, computers calculate", has the 1961 Lee maze algorithm, 1971 CANCER, 1973 SPICE1, 1975 SPICE2, 1984 PSpice, 1985 OrCAD, 1989 Specctra and 1992 KiCad. The blue band (1993–2020), "cheap boards and circuits as code", has JLCPCB founded in 2006, FreeRouting's source released in 2014, and SKiDL in 2016. The orange band (2021–), "AI enters design", has the 2021 AlphaChip paper (reproducibility dispute), JITX in 2022, Flux Copilot and Allegro X AI in 2023, AnalogCoder and the Quilter beta in 2024, Quilter's 843-part board booting in 2025 (company announcement), and in 2026 a top score of 8% on HWE-Bench and agentic EDA](/uploads/fc64af186c172593.webp)

### Computers take over the calculation (1961 to the 1990s)

**The simulator came out of a class project.** The program Laurence Nagel at UC Berkeley wrote up in his master's report in 1970 was called CANCER, an acronym for "Computer Analysis of Nonlinear Circuits Excluding Radiation". In 1973 Nagel and Pederson revised it and released SPICE1, and in 1975 Nagel's doctoral thesis became SPICE2. Because Berkeley gave the source out widely, SPICE became the de facto world standard, and in 2011 it was named an IEEE Milestone.

SPICE's input is not a picture but text. You write one line per part, such as "R1 between node 3 and node 5, 10kΩ". A list of parts and connections: a **netlist**. The experiment in this article also comes back to this format in the end.

**That calculator came down to the personal computer.** In 1984 MicroSim released PSpice for the PC (release date from secondary sources). In 1985 OrCAD released a program for drawing schematics on DOS. The two companies merged in 1998 and were acquired by Cadence in 1999. That is why the PSpice name is on a Cadence product today.

**Board routing was maze solving.** In 1961 C. Y. Lee published an algorithm that finds the shortest path between two points on a grid by spreading numbers outward from the start like a ripple. If a path exists, it always finds it. It is the root of automatic board routing. The commercial autorouter Specctra appeared in 1989, and when it was sold to Cadence in 1997 the US Federal Trade Commission attached conditions, saying it was "the only viable commercial router". Even so, engineers distrusted autorouting for a long time. One Altium blog post is titled "A History of Failed Design Automation".

### Cheap boards and circuits as code (the 1990s to 2020)

In 1992 Jean-Pierre Charras released KiCad. From 2013 CERN contributed developers and brought it up to the level of commercial tools, and version 10.0 came out in March 2026. Everything from schematic to board layout can now be done for free.

Board prices fell too. JLCPCB, founded in 2006, now advertises "from $2 for 5 boards". Compared with the US group-order service OSH Park, which takes two-layer boards at $5 per square inch (for 3 boards), that is a difference of tens of times for a 10×10cm board. Turning a hobby circuit into a board now costs about as much as a cup of coffee.

And circuits started being **written as text** again. SKiDL, which describes parts and connections in Python, appeared in 2016, followed by JITX in 2022, atopile in 2023 and tscircuit in 2024. Write a circuit as code instead of a drawing and you get version control, reuse and automatic checks. And it becomes easier for AI to handle.

### AI enters design (2021–)

**Chips came first.** In 2021 Google published a paper in Nature on using reinforcement learning to place large blocks on a semiconductor chip (now called AlphaChip). It claimed results equal to or better than people's, but in 2023 reproduction studies pushed back, and Nature carried an editor's note for a while. As of the updated re-evaluation released in March 2026, the dispute has not ended.

**2023 was the year of the copilot.** Flux put conversational AI into its browser circuit tool (April), Cadence released Allegro X AI to automate board placement and routing (April), and Synopsys added a conversational assistant to its chip design tools (November). In 2025–2026 the name changed to agent. Siemens EDA AI (June 2025), Cadence AuraStack (July 2026) and Synopsys AgentEngineer (September 2026) came out, and in August 2026 Flux opened an MCP server so that outside agents such as Claude can work on circuits directly.

**In board placement and routing, Quilter is furthest ahead.** In December 2025 it announced that it had used AI to place and route an 8-layer Linux computer board with 843 parts, and that the board booted the first time power was applied. Human work was 38.5 hours, it said, under a tenth of an expert estimate of 428 hours. All of these are the company's own figures.

**Academic benchmarks, however, are unsparing.**

| Benchmark (published) | What it asked for | Result |
|---|---|---|
| [HWE-Bench](https://arxiv.org/abs/2603.18102) (2026-03) | A board schematic from scratch, given only functional requirements and datasheets | Fully correct designs, best **8.15%** (Claude Sonnet 4.5) |
| [EDA Bench](https://openreview.net/forum?id=aKZbHRJpNo) (ICML 2026) | 35 tasks reconstructing KiCad board projects | Overall **4.58%**. 21 produced files that opened, but most failed functional checks |
| [PCBSchemaGen](https://arxiv.org/abs/2602.00510) (2026-01) | 227 tasks with real ICs, with a **deterministic checker + datasheet schema** attached | **81.3%** pass on average |
| [arXiv 2609.26830](https://arxiv.org/abs/2609.26830) (2026-09) | 150 LLM-generated circuits run in ngspice | **10.7%** ran with no warning while one terminal was disconnected |

The tasks differ, so the numbers cannot be compared directly. But the direction is clear. Benchmarks where AI draws from scratch on its own stay in single digits, while the one with a deterministic checker attached passes eight in ten. The last row is worth noting too. A voltage divider with one resistor left floating put out 5.00V instead of 2.50V, and the simulator gave no warning at all. **A simulation that runs does not mean the circuit is right.** That is why the main character of this experiment is not the AI but the checker.

## What it means to design a circuit, and to verify one

Before the examples, let's separate the two jobs.

**Design** is turning words into parts and connections. "Sound when the door opens" breaks down like this.

- **Sensing**: how do you know the door is open? A magnet and reed switch, infrared, a tilt sensor.
- **Deciding**: to sound only once at the moment it opens, what keeps time? A 555 timer, an RC circuit, a microcontroller.
- **Output**: what makes the sound? An active buzzer that sounds on plain DC, or a piezo speaker that must be driven with AC.
- **Power**: use the 9V as is, or step it down to 5V? How much current leaks while idle?

Then you calculate values for each part. What resistor and capacitor give one second of sound (time = resistance × capacitance)? How many volts does the sensor put out when it sees white tape? Everything needed for these calculations is in the datasheets: threshold voltage, standby current, rated current. So the idea of "read the IC datasheets and design the circuit" suits AI fairly well.

**Verification** is checking whether that design meets the requirements. It has four layers.

1. **Connection check (ERC)**: is a wire connected to a pin that doesn't exist, is a pin that should be connected left floating, are the battery's + and - shorted? This stage sees whether the circuit "makes sense".
2. **Simulation**: SPICE computes voltage and current over time. You put in a scene of the door opening and closing and see when the buzzer sounds.
3. **Worst case**: even the same 2N7000 transistor can have a turn-on threshold of 0.8V or of 3V (the datasheet range). The battery starts at 9V and wears down to 6.5V. A circuit that works at typical values often fails at worst case.
4. **Firmware**: once a microcontroller is involved, the circuit alone cannot settle it. You have to actually run the program.

## So here is what I built: requirements → AI design → automatic checks → breadboard

![A flow diagram of the vibe circuit design experiment. ① The person's requirements (6–7 lines in words) → ② AI designer (given: the requirements, part cards for 24 parts with pin names and datasheet essentials, the file format; simulators not allowed) → ③ design file (parts list, nets written by name such as U2.PB2, explanation, C firmware if there is a microcontroller). On the lower row, ④ automatic checker (ERC: missing parts, missing pin names, disconnected pins, shorts / ngspice test bench: battery at 9V and 6.5V, worst case, rated current / virtual chip simavr: run the firmware on an ATtiny85 and decode the display signal) → ⑤ if it passes, automatic breadboard placement plus parts list and quote. Below: "If it fails, send the report straight back to ② and get the next revision"](/uploads/9797450d70884120.webp)

The setup was this.

**The AI designer** is a Claude agent launched fresh each time. It knows nothing else about this experiment. It receives three things: the requirements in words, **part cards** for the 24 parts it may use, and the design file format. A part card holds only pin names and datasheet essentials. For example, the 2N7000's is "Pins: S, G, D / threshold 0.8–3V, 200mA". It was not allowed to use a simulator or compiler. Designing with hand calculation and knowledge alone was meant to show how much "AI on its own" gets right.

**Pins were connected by name, not number.** On the 78L05 regulator in the TO-92 package, the leg order is output, ground, input. That is the reverse of the common 7805 (input, ground, output), and people get it wrong often too. The design file uses only names such as "U1.OUT", and translating names into physical pins happens in one place only, the part card. This is the approach tools such as atopile take, and the HWE-Bench paper also notes that clearly named pins give higher connection accuracy. It blocks one kind of pin-number hallucination by structure.

**The checker** I built together with Claude. Most of this episode's time went into it.

- **ERC**: catches parts not on the part cards, nonexistent pin names, disconnected pins and battery shorts.
- **ngspice test bench**: converts the design file into a SPICE netlist and runs it. For the 555 timer, the 78L05 and the reflective sensor, instead of manufacturer models I wrote new **models that behave according to the behavior and typical values in the datasheets**. It runs at a 9V battery, at 6.5V, and at the worst case of part variation.
- **Virtual chip**: microcontroller firmware is built with avr-gcc and run on an AVR simulator called simavr. A signal of the belt turning is fed into the sensor pin, and the display signal lines are decoded to read the number on screen.
- **Breadboard placer**: tries the passing circuit on 170-hole → 400-hole → 830-hole boards in that order and picks the first that fits (simulated annealing).

## Example 1: the door-open chime

The requirements were these. A magnet goes on the door and a reed switch on the frame. When the door opens, it beeps once (0.5–3 seconds), and does not sound again even if the door stays open. When closed, it is silent. If the door is closed and opened again within 1 second, it still sounds. One battery lasts a year, and it still sounds when worn down to 6.5V. The fewer parts, the better.

I expected something like two 555 timers. In fact, the 555 circuit I first built by hand to test the checker drew over 300µA in standby alone and would not last a year. When the door opened, the trigger stopped at 4.5V and it did not sound at all. The checker caught my mistakes first.

**The AI's first revision (r1) had no IC.** Seven parts including the battery, produced in 64 seconds.

- It uses a changeover reed switch. With the door closed, the common terminal connects to ground; with it open, to battery +.
- That common terminal → capacitor → MOSFET gate. A resistor runs from the gate to ground.
- The moment the door opens, one side of the capacitor jumps to 9V, and since a capacitor cannot change its voltage instantly, the gate jumps to 9V too. The MOSFET turns on and the active buzzer sounds.
- As the capacitor charges through the resistor, the gate voltage falls exponentially, and once it drops below threshold the sound stops. Even if the door stays open, the already charged capacitor does not create another signal.
- When the door closes, a diode empties the capacitor within a few ms. So opening it again 1 second later sounds just like the first time.
- While closed, there is no path for current at all. **Standby current 0.** No power switch is needed either.

It is the textbook "one-shot made with a differentiator circuit". A 1M resistor and a 1µF capacitor give a time constant of 1 second. The AI calculated even the threshold spread and wrote that it would sound for 0.94–1.93 seconds at 9V and 0.62–1.61 seconds at 6.5V.

**At typical values, the checker passed everything.** 1.40 seconds at 9V, 1.08 seconds at 6.5V, standby current 0, and the re-open test passed. But **it failed at worst case.** With a 2N7000 at the lowest threshold of 0.8V, and the upper limit of leakage current allowed by aluminum electrolytic capacitor datasheets (0.01CV or 3µA, whichever is larger), it sounded without stopping from the moment the door opened until it was closed. Left open, 7.5mA flows and the battery is dead in three days.

![A graph comparing the MOSFET gate voltage at worst case. When the door opens at 4 and 9 seconds, both lines jump to 9V and then fall exponentially. r1 (1M·1μF, red) stops falling near 1.6V and stays above the 0.8V threshold dotted line, and in the band below r1 sounds the whole time the door is open. r2 (100k·10μF, blue) falls to around 0.3V, below the threshold, and the sound stops after 2.4 seconds](/uploads/111c49f577219249.webp)

The cause is right there in the graph. A few µA leaking through the electrolytic capacitor, across a 1MΩ resistor, leaves a little over 1.6V on the gate. That is above the 0.8V threshold, so the MOSFET does not turn off. The hand calculation put leakage below 0.1µA, but the datasheet upper limit is tens of times that. Most real capacitors leak far less than the limit, but when one unlucky capacitor meets one unlucky transistor, the buzzer at the front door does not stop.

**When the report went back, the AI produced a second revision (r2).** It cut the resistor from 1M to 100k and raised the capacitor from 1µF to 10µF. The time constant stays at 1 second, but the gate voltage the leakage leaves drops to a tenth, 0.17V, well below the minimum threshold of 0.8V.

And it pointed out one more problem that was not in the report. With the capacitor ten times larger, when the door closes the capacitor empties all at once through the reed switch and diode, and the surge current could exceed the reed switch's rating (0.25A). So it added another 100Ω resistor to hold the surge current to 88mA.

To see whether that point was right, I added a **rated current check** to the checker. After adding it, I ran r1 again, and r1 also sent 1.1A through the reed switch the moment the door closed. It lasts only about 10µs, but reed switch contacts are vulnerable to this kind of capacitor discharge. The AI pointed out first what the checker had missed, and thanks to that the checker grew a step.

r2 passed every check. At worst case, 2.42 seconds at 9V and 0.73 seconds at 6.5V. The AI's hand-calculated values were 2.36 and 0.71 seconds. Surge current 79mA.

![Schematic of the door-open chime r2. The + of the 9V battery BT1 is the VBAT line at the top, and - is the ground line at the bottom. The upper terminal of the changeover reed switch SW1 connects to VBAT and the lower terminal to ground, and the common terminal goes through R2 100Ω and electrolytic capacitor C1 10μF to the gate node. From the gate node, D1 1N4148 (cathode toward the gate) and R1 100k go down to ground, and the gate connects to Q1 2N7000. Above Q1's drain, the active buzzer BZ1 runs up to VBAT](/uploads/37d2674f8014d2bf.webp)

![The door-open chime placed automatically on a 170-hole mini breadboard. In the upper half are buzzer BZ1, MOSFET Q1, resistors R1 and R2, diode D1 and electrolytic capacitor C1, with one jumper wire. The 9V battery and reed switch plug into holes in the upper half by wire](/uploads/27a4fabee95aed0c.webp)

The breadboard uses only the upper half of one 170-hole mini. There is one jumper wire. The parts cost a little over $1, and even with the mini breadboard (SparkFun listed price $5.25) it comes to about $8.

## Example 2: the treadmill belt speedometer

The requirements were these. Stick one piece of white reflective tape, 2cm wide, on the edge of the belt, use a reflective sensor to time the interval between passes of the tape, and show km/h on a 4-digit display. The length of one belt loop is measured with a tape measure and entered in the firmware (3.000m for the test). 1–20km/h, with an error of ±1% or ±0.1km/h, whichever is larger. When the belt stops, 0.0 within 5 seconds. Normal operation from 9V down to 6.5V.

Calculation is needed, so a microcontroller goes in. In 147 seconds the AI produced a 15-part design and a C firmware file.

- **Power**: 9V → slide switch → 78L05 (5V). When the battery wears down to 6.5V, the 78L05's 1.7V dropout makes it 4.8V, but it calculated that the ATtiny85 and the display still run at that voltage.
- **Sensor**: 330Ω on the reflective sensor's infrared LED (about 11mA), and a 10k pull-up on the phototransistor. 0.2V on white tape, 4V on the black belt. It noted that it did not use the microcontroller's internal pull-up (20–50k) because that could drop to LOW even on the black surface.
- **Clock**: here the AI read the datasheet properly. The ATtiny85's internal oscillator has a factory calibration accuracy of ±10%. That cannot meet a ±1% requirement, so it added an **8MHz crystal**, giving up two pins in return.
- **Measurement**: each time the leading edge of the tape passes, an interrupt timestamps it in 8µs units, and the speed comes from the loop time T. Measuring between identical edges cancels out the effect of the sensor threshold and the tape width.

And **it pointed out a contradiction in the requirements first.** With only one piece of tape, one loop takes 10.8 seconds at 1km/h. When no tape has arrived for 5 seconds, there is physically no information to tell whether the belt has stopped or is turning very slowly. The AI chose to keep the 1km/h measurement, and wrote that in this range it takes up to about 16 seconds for 0.0 to appear. To keep the 5 seconds, it said, stick on two or three pieces of tape.

The checker looks at the circuit first. The sensor voltage was 4.06V on the black belt, 3.25V on a belt worn to gray, and 0.17V on white tape, within the range where the microcontroller clearly separates HIGH and LOW. Even at a 6.5V battery, the microcontroller supply was 4.72V. Operating current is 39mA, so a 9V battery lasts about 15 hours. The firmware built to 1,124 bytes of flash and 24 bytes of RAM.

Next, the **virtual chip** runs the firmware. Over 126 seconds the belt was changed 0 → 10 → 3 → 16 → 20 → 6.5km/h → stop → 1km/h → stop, and the numbers were read off the display signal lines.

![A graph of display readings as the belt speed changes. The thick gray staircase is the actual belt speed, and the blue line is the reading from the AI's design with the crystal, which follows 10.0, 3.0, 16.0, 20.0, 6.5 and 1.0 exactly in each segment. The red dotted line (same firmware, internal RC -10%) reads high at 11.1, 3.3, 17.8 and 22.2, and the orange dotted line (+10%) reads low at 9.1, 2.7, 14.5 and 18.2. A note says that after stopping from 1km/h, it takes 14.7 seconds for 0.0 to appear](/uploads/c04cf9f7b6acf7f2.webp)

- The display was right in every segment. 10.0, 3.0, 16.0, 20.0, 6.5, 1.0.
- Stopping from 6.5km/h gives 0.0 after 0.9 seconds.
- **Stopping from 1km/h gives 0.0 after 14.7 seconds.** It fell exactly where the AI said in advance it would.

Where the requirements collide with physics, neither the AI nor the checker can solve it. A person has to choose. I changed the requirement to "when stopping below 2.5km/h, it may wait up to one and a half loops", and the same design passed as is.

**I also ran a control experiment to see whether the crystal was really needed.** The same firmware ran without the crystal, on a clock that was off by the datasheet's limit for the internal oscillator (±10%). At 10km/h it showed 11.1 and 9.1. The screen works normally, so you cannot tell by eye. The judgment the AI made from reading one line of the datasheet is what prevented that difference.

![The treadmill speedometer placed automatically on a 170-hole mini breadboard. The ATtiny85 straddles the center channel; in the upper half are crystal Y1, two 22pF capacitors and reset pull-up R1, and in the lower half are the slide switch, 78L05, capacitors C1, C2 and C3, and sensor resistors R2 and R3. Seven jumper wires connect the rows, and the 9V battery, reflective sensor and 4-digit display connect by wire from below](/uploads/6115438d6f6d0301.webp)

This one also fit on a single 170-hole mini breadboard. There are seven jumper wires. Most of the parts cost is the ATtiny85 (LCSC $3.01) and the reflective sensor ($1.58), so including the breadboard it comes to about $13. You need to pick a TM1637 module that has decimal points for the display. The modules commonly sold are made for clocks and have only a colon in the middle, with no decimal points.

## Try it yourself

In the dissector below you can follow both examples step by step. Pick an example with the buttons at the top, and a step with the six tabs below them.

```map /embed/circuit-vibe-2026-en.html 4:5
The Vibe Circuit Design Dissector. Pick one of two examples, the door-open chime or the treadmill speedometer, and move through 1 Requirements (sentences in words) → 2 AI design (parts, nets, explanation, firmware, comparing r1 and r2) → 3 Automatic checks (ERC, ngspice and virtual chip reports) → 4 Simulation (for the chime, replays the gate voltage and buzzer for each worst case; for the speedometer, replays the belt and the 7-segment digits drawn by the virtual chip, compared with the internal RC clock) → 5 Breadboard placement (point at a net and the same net lights up) → 6 Parts list and quote.
```

In the simulation step, switch between the chime's r1 and r2 and the worst-case buttons, and the graph above moves. For the speedometer, press play and the belt turns at 10× speed, and the digits drawn by the virtual chip appear on the display. The digits are decoded from the bits the firmware actually sent out on the display signal lines.

## Where it went wrong

I made more mistakes building the checker than the AI did. In order:

- **The 555 model half worked.** At first I imitated the 555's memory element (latch) with a continuous function. Then near the threshold the output stalled in a state that was neither 0 nor 1, and the oscillator stopped. I changed the latch to a digital element, and this time, the moment the voltage sat on the boundary, an "unknown" state stayed in the latch and the output got stuck at 0.5. Only after removing the boundary band did it match the datasheet calculation (1.012ms) within 0.6%.
- **The test circuit I built by hand was wrong.** The 555 chime I built to test the checker did not sound because the trigger voltage stopped at 4.5V. The second version drew 1.1mA in standby, good for 23 days. The checker did its job.
- **The simulator made a sound that wasn't there.** When I first ran the AI's r1, the buzzer sounded for 2.6 seconds the moment the door closed. When the diode emptied the capacitor instantly, SPICE's default integration method (trapezoidal) caused numerical ringing and produced a 6V on the gate that did not exist. Switching the integration method to gear made it go away. Had that gone into the report as is, the AI would have "fixed" a working circuit. The checker has to be checked too.
- **The checks were short at first.** The speedometer's "0.0 within 5 seconds of stopping" was not in the first checker. It passed by looking only at the number at the end of each segment, and the check was added later. The rated current check was added after the AI raised it in r2.
- **There are still things it misses.** Look closely at the speedometer graph and 0.0 appears briefly when the speed is switched suddenly from 10km/h to 3km/h. The loop time suddenly triples, so the firmware decides "stopped". A real treadmill slows down gradually, so it would happen less, but it was not in the checker's test items, so it passed.

The AI's only mistake was the leakage in the r1 chime. Even that was fine at typical values and only showed up once the datasheet's worst-case values went in. In the other direction, the AI raised two things the checker had not asked about (the surge current when the capacitor discharges, and the physical limit of a single piece of tape) first.

## How close to something you can order?

Where this experiment got to is **a verified netlist + firmware + breadboard layout + parts list and quote**. For anyone who wants to build it on a breadboard, that is enough. Unit prices in the parts list use LCSC and SparkFun listed prices as of 20 October 2026, and the rest are estimated from small-quantity market prices.

Turning it into an ordered board takes one more step: **placement and routing (layout)**. You have to set each part's footprint on the board, place them, draw the traces and generate Gerber files before you can upload to JLCPCB. This step is where Quilter, DeepPCB and Cadence are now aiming AI, and it can also be done with KiCad and the open-source autorouter FreeRouting. This time I did not go that far. But since the netlist is organized by pin name and fully verified, the material to feed a layout tool is ready. The board cost itself is not the problem. Five 10×10cm two-layer boards start at $2.

## Why it worked in one click

This time a circuit really did come out of a few lines of requirements. The chime in two tries, the speedometer in one. There are three reasons it worked.

**The circuit knowledge is all in textbooks and datasheets.** A differentiator one-shot, a pull-up resistor, a crystal oscillator, input capture. The AI invented nothing new. What it does quickly is pick the pieces that fit the requirements and calculate their values. 64 seconds, 147 seconds.

**The checker did the doubting for the AI.** By hand calculation at typical values, the r1 chime was perfect. Only after putting in the datasheet's worst-case values and running the simulator did the problem show. It is the same story as the higher numbers for the checker-equipped entry in the benchmark table above.

**What people have to do is clearly left over.** When the requirements collide with physics, what to give up (the 1km/h measurement, or the 5-second stop display), what to fill the checker with, and plugging in the real thing. This experiment went as far as simulation; nothing physical was built.

## If you want to try it

- **Give the AI a parts list.** Say "use anything" and you easily get part numbers that don't exist or the wrong pinout. Just write down the parts to use, their pin names and a few key datasheet numbers.
- **Have it connect pins by name.** Don't let it use numbers. The 78L05 alone is reason enough.
- **Attach a simulator.** LTspice and ngspice are free. Run once at typical values, once at a worn-down battery, and once at each end of part variation. Every real mistake in this experiment came out at worst case.
- **Doubt the simulator's results too.** If a simulation "works oddly well or fails oddly", look first at the integration method, the models and the test conditions.
- **If there is a microcontroller, run the firmware on a virtual chip too.** There are tools such as simavr (AVR) and Wokwi (Arduino, ESP32, in the browser).

## What it can't do

- **Nothing physical was built.** All results are simulation. Reed switch contact bounce, the buzzer's actual sound, sunlight reaching the reflective sensor and treadmill vibration are not in the models.
- **The models imitate datasheets.** The 555, 78L05 and reflective sensor are not manufacturer models but models written from the behavior and typical values in the datasheets. Temperature changes and aging were not included.
- **It can't use parts outside the part cards.** It designed only within the 24 parts. Real vibe design would need one more step for part search and datasheet reading.
- **No board layout was done.** It stops at the breadboard.
- **The examples are small.** Around 15 parts. That is a different size from the board-level circuits HWE-Bench deals with.

You still have to know circuits to open PSpice. But the work of someone who knows circuits is now moving from "drawing them" to "deciding what to check". Each check put into the checker this time is an item on that list.

### If you enjoyed this, please leave a comment.

## Sources

- SPICE and CANCER: IEEE Milestone [SPICE Circuit Simulation Program](https://ethw.org/Milestones:SPICE_Circuit_Simulation_Program), Nagel and Pederson [ERL-M382](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1973/22871.html) (1973), Nagel [ERL-M520](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1975/9602.html) (1975)
- OrCAD: Cadence [40 Years of OrCAD](https://resources.pcb.cadence.com/blog/40-years-of-orcad-from-basement-beginnings-to-pcb-legend). PSpice release year and acquisition dates from secondary reports (press releases reprinted by EE Times)
- Automatic routing: C. Y. Lee, An Algorithm for Path Connections and Its Applications, IRE Trans. EC-10(3) (1961), FTC [Cadence and CCT decision](https://www.ftc.gov/node/39580), [FreeRouting](https://github.com/freerouting/freerouting), Altium [A History of Failed Design Automation](https://resources.altium.com/pcb-design-blog/to-autoroute-or-not-to-autoroute-a-history-of-failed-design-automation)
- KiCad: [About](https://www.kicad.org/about/kicad/), [10.0 release](https://www.kicad.org/blog/2026/03/Version-10.0.0-Released/)
- Board prices: [JLCPCB](https://jlcpcb.com/), [OSH Park](https://docs.oshpark.com/services/)
- Circuits as code: [SKiDL](https://github.com/devbisme/skidl), [JITX](https://www.jitx.com/blog/series-a-announcement), [atopile](https://github.com/atopile/atopile), [tscircuit](https://github.com/tscircuit/tscircuit)
- AlphaChip: [Nature 2021](https://www.nature.com/articles/s41586-021-03544-w), [Addendum 2024](https://www.nature.com/articles/s41586-024-08032-5), re-evaluation [arXiv 2302.11014](https://arxiv.org/abs/2302.11014) (v3 2026-03), rebuttal [arXiv 2411.10053](https://arxiv.org/abs/2411.10053)
- Commercial AI: [Flux Copilot](https://www.flux.ai/p/blog/flux-copilot-the-first-ai-powered-hardware-design-assistant), [Flux MCP](https://email.flux.ai/p/blog/summer-2026-updates-flux-mcp-server-and-chat-mode), [Allegro X AI](https://www.businesswire.com/news/home/20230406005098/en/Cadence-Introduces-Allegro-X-AI-Accelerating-PCB-Design-with-More-Than-10X-Reduction-in-Turnaround-Time), [Synopsys.ai Copilot](https://news.synopsys.com/2023-11-15-Synopsys-Announces-Synopsys-ai-Copilot,-Breakthrough-GenAI-Capability-to-Accelerate-Chip-Design), [Synopsys AgentEngineer](https://www.synopsys.com/ko-kr/korean/press-releases/26-09-28-synopsys-powers-autonomous-engineering.html), [Siemens EDA AI](https://news.siemens.com/ko-kr/siemens-eda-ai-dac-2025/), [Cadence AuraStack](https://www.cadence.com/go/aurastack), Quilter [Project Speedrun](https://quilter.ai/project-speedrun/download) (company announcement)
- Academic: [HWE-Bench](https://arxiv.org/abs/2603.18102), [EDA Bench](https://openreview.net/forum?id=aKZbHRJpNo), [PCBSchemaGen](https://arxiv.org/abs/2602.00510), [arXiv 2609.26830](https://arxiv.org/abs/2609.26830), [CircuitLM](https://arxiv.org/abs/2601.04505), [AnalogCoder](https://arxiv.org/abs/2405.14918)
- Breadboards: Portugal [US D228,136](https://patents.google.com/patent/USD228136S/en) (filed 1971), BusBoard [BB170 datasheet](https://www.busboard.com/documents/datasheets/BPS-DAT-(BB170)-Datasheet.pdf), prior work on automatic placement: Mekonnen, [Automatic protoboard layout from circuit schematics](https://dspace.mit.edu/handle/1721.1/91847) (MIT, 2014)
- Datasheets: [NE555](https://www.ti.com/lit/ds/symlink/ne555.pdf), [TLC555](https://www.ti.com/lit/ds/symlink/tlc555.pdf), [UA78L05](https://www.ti.com/lit/ds/symlink/ua78l.pdf), [TCRT5000](https://www.vishay.com/docs/83760/tcrt5000.pdf), [ATtiny85](https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet.pdf), [TM1637](https://akizukidenshi.com/goodsaffix/TM1637_V2.4_EN.PDF), [Energizer 522](https://data.energizer.com/pdfs/522.pdf)
- Tools: [ngspice](https://ngspice.sourceforge.io/), [simavr](https://github.com/buserror/simavr), avr-gcc, [schemdraw](https://schemdraw.readthedocs.io/)
- Unit prices: LCSC [NE555P](https://www.lcsc.com/product-detail/Timer_TI_NE555P_NE555P_C46749.html), [ATTINY85-20PU](https://www.lcsc.com/product-detail/C965497.html), [TCRT5000L](https://www.lcsc.com/product-detail/C24085.html), SparkFun [mini breadboard](https://www.sparkfun.com/breadboard-mini-modular-white.html) (all listed prices as of 2026-10-20)
- The design and verification results, schematic, breadboard layouts and graphs were all produced by this article's experiment. The schematic drawing was drawn separately with schemdraw code from the design file