AI agents for hardware design · Hardware Academy

Systems first, geometry second

You may have seen a post where an AI agent produced a manufacturable heat pump: refrigerant piping and wiring first, a simulation, then 3D geometry checked by DFM rules, and finally an animated assembly order. Treat it as a pipeline claim to understand and test, not as magic. The structure is sound, and it is the same structure behind PCB design, EV charging site design and your own local 3D agent. What matters is what each stage needs, what a model can and cannot do there, and how you would know the result is good. Ask three questions of any such demo: which checks ran, what would they not catch, and has anyone built and tested the part?

The pipeline, stage by stage

Requirements. A brief becomes a spec in which every target has a unit, a test condition and a limit: 10 kW of heat at 7 °C outdoor air and 35 °C water, R290 refrigerant, 240 V, inside 1.2 × 0.5 × 1.0 m.
System schematics. Two graphs, not drawings: the P&ID of the refrigerant loop (compressor, condenser, expansion valve, evaporator, reversing valve, sensors and safety devices, in ISA-5.1 symbols) and the electrical single-line and wiring (supply, breaker, contactor, inverter, fans, controller).
Component selection. Each duty is matched to a real part whose datasheet envelope covers the operating point: a compressor with 3.1 kW input, a brazed-plate heat exchanger, an electronic expansion valve, and wire sized to the current.
End-to-end simulation. The refrigerant cycle (properties from a library such as CoolProp) and the electrical model run together and give state points, heat output, COP, pressure drops and current.
Geometry through a CAD kernel. The agent writes code that places each component at the port positions the P&ID demands, routes tubes and wires, builds the frame and exports STEP.
DFM and DFA checkers at “compile time”. Rule checkers read the geometry and return diagnostics the way a compiler does: tube bend radius at least 2 × OD, wall at least 1.5 mm, hole rim at least one diameter from the edge, and a tool path to every screw.
Subassemblies and assembly order. Parts are grouped (fan module, compressor skid, frame) and sequenced so that each can be inserted along a free path, which is what the assembly animation shows.

Failures loop back to the cheapest stage that can fix them: a DFM violation sends diagnostics to the geometry stage, an undersized compressor sends the simulation result back to component selection, and a netlist mismatch sends geometry back to the schematics. That is why it is a pipeline with feedback and not one-shot generation.

The loops only converge if the feedback is exact. A good diagnostic is a compiler error for geometry: a rule id, the part, the measured value, the limit and a location, for example HOLE_EDGE bracket_fan H3: 4.9 mm, needs 6.5 mm. The agent edits one parameter and reruns. Vague feedback such as “too close to the edge” makes the loop wander, while exact numbers make it converge in a few iterations.

Swipe sideways to see the whole figure.

The design-agent pipeline: seven stages, each with a machine check, and four feedback loops (dashed) that return an error to the stage that can fix it cheaply.

Why systems first works

The schematic is a small graph with checkable physics, while the geometry has vastly more degrees of freedom. Fixing the systems level first turns the geometric problem into packing and routing against hard requirements: port positions, tube diameters, clearances and an envelope. A wrong line size costs seconds in the simulator and a recall in the field. The same graph also feeds the 3D model and the BOM, so a layout-versus-schematic check can compare them automatically, as layout-versus-schematic checks do for chips and boards. PCB design already works this way: schematic, then layout, then DRC.

What AI does well, and what it does badly

Well: searching catalogs with thousands of parts, boilerplate (BOM tables, wire lists, the fortieth bracket), keeping names, units and IDs consistent across schematic, BOM and 3D, and trying variants quickly.
Badly: tolerances and fits, tacit shop knowledge (which press brake can hold a 1.5 mm flange), physics nobody simulated (compressor vibration, defrost, oil return, acoustics), left and right and mirrored geometry, and regulation such as the charge limit for flammable R290. It also invents plausible part numbers and datasheet values, so every number needs a lookup.

Three layers of verification

Rule-based checks are cheap, fast and complete for exactly the rules written, and blind to anything not encoded. Simulation covers physics inside its validity domain and is only as good as its inputs. Human review and test cover the rest: a prototype, a pressure test, a certification such as UL 60335-2-40 for heat pumps, and a named engineer who signs. An AI-generated design earns trust by passing all three, and each layer catches what the others cannot. The practice section turns the layers into a ten-check rubric you can score a design against.

Neighbours and your own projects

The same shape exists elsewhere. Zoo (formerly KittyCAD) offers text-to-CAD and a code-first CAD language. Open-source CadQuery and build123d agents write a script, run it and retry on the error. Flux and JITX bring AI and code to PCB design, Quilter generates board layouts with physics-driven search, and several vendors sell AI P&ID digitization. Your EV charging site-design engine is the same pipeline in another domain: requirements (stalls, kW per stall, utility service) become a single-line diagram and load calculation, parts are selected (transformer, switchboard, conductors, EVSE), simulation checks voltage drop and load management, geometry places stalls and trenches, and code checkers (NEC 625, accessibility rules such as CBC 11B) play the role of DFM. Your local 3D agent is the geometry stage with a render-and-look critic instead of a rule-based one.

Interactive: run the pipeline and break it

Press Play on the clean run, then inject a defect. Watch which check fails, where the dashed loop sends the error, and which stages run again. The undersized compressor is caught before any geometry exists, which is the whole argument for systems first. Finish with the hidden fastener and switch the assembly-access check off.

Design pipeline: stages, checks and feedback loops

Watch a heat-pump design move through seven stages. Inject a defect to see which check catches it and where the loop returns. Click a stage for its inputs and outputs.

Swipe sideways to see the whole diagram.

step 1 / 22Stage 1: Requirements. Turns the brief into a numbered spec in which every target has a unit, a test condition and a limit.

Stage 1: Requirements(following the animation)

Turns the brief into a numbered spec in which every target has a unit, a test condition and a limit.

Inputs

Brief: a 10 kW air-to-water heat pump for a house
Operating point: 7 °C outdoor air, 35 °C water supply (A7/W35)
Constraints: R290 (propane), 240 V single phase, 1.2 × 0.5 × 1.0 m

Outputs

Spec table with units and limits
Test plan: one test per requirement
Risk list: R290 is flammable, so charge limits apply

Checks

·Every requirement has a number and a unit
·Every requirement maps to a test

Typical tools: LLM with a spec template; a human signs off.

Stage 1: Requirements. Turns the brief into a numbered spec in which every target has a unit, a test condition and a limit.

Scenario

Try Hidden fastener, then switch the assembly-access check off. With no DFA check written, every DFM rule still passes and the defect reaches the shop floor. Artifacts are illustrative numbers for a 10 kW R290 unit.

In practice: score an AI-generated design

Practice

A ten-check rubric for an AI-generated heat pump

An agent hands you its design for a 10 kW air-to-water heat pump (R290, 240 V, A7/W35, spec COP at least 4.0). Its report says:

Spec: 24 requirements, 22 with a test (none for the 55 dB(A) noise limit or the defrost time).
Schematic: refrigerant loop closed, high-pressure switch and relief valve present, electrical rule check clean.
Parts: 31 part numbers, 30 found in the supplier catalog. The compressor, SCX-310-R290, is not there.
Simulation at A7/W35: condenser 10.2 kW, evaporator 7.5 kW, compressor input 2.4 kW.
Electrical: compressor rated-load current 11.5 A, fan 1.2 A. The agent chose 14 AWG wire and a 15 A breaker.
Geometry: 22 of 22 refrigerant lines and 31 of 31 wires match the schematic, no interference.
DFM: every tube bend passes. One bracket hole (Ø6.5 mm) has its rim 4.9 mm from the edge.
DFA: tool-access sweeps ran for 41 of 43 fasteners. The 2 fan-bracket screws were not swept.
Provenance: script and parameters are in git with pinned versions. No vibration, defrost or R290 charge-limit analysis. No named reviewer.

Score each of the ten checks pass, fail or unknown, give the total, say which stage every failure returns to, and decide: release, fix, or reject.

Traceability: every requirement maps to a test.
Schematic completeness: loop closed, safety devices present, rule check clean.
Real parts: every part number resolves and sits inside its datasheet envelope.
Energy balance: condenser heat equals evaporator heat plus compressor input within 3%.
Performance: heat and COP meet the spec, and COP is 35 to 55% of the Carnot limit.
Electrical sizing: wire ampacity at least the minimum circuit ampacity (1.25 × the largest compressor current plus other loads), with a breaker within the nameplate maximum.
Layout versus schematic: the geometry netlist equals the P&ID and wire list, with no interference.
DFM: bend radius at least 2 × OD, hole rim at least one diameter from the edge, wall at least 1.5 mm.
DFA: every fastener has a verified tool path and the assembly order has no cycle.
Provenance and review: regenerated from versioned source, physics outside the simulation covered, a named human signs.

Answer

#	Verdict	Evidence	Returns to
1	Fail	22 of 24 requirements have tests; noise and defrost have none.	Requirements
2	Pass	Loop closed, safety devices present, rule check clean.	-
3	Fail	SCX-310-R290 does not exist in the catalog. A replacement changes the compressor, so the simulation must run again.	Components, then Simulation
4	Pass	7.5 + 2.4 = 9.9 kW against 10.2 kW: 2.9% mismatch, barely inside 3%.	-
5	Pass	COP = 10.2 / 2.4 = 4.25, above 4.0. Carnot at 7 °C and 35 °C is 308.15 / 28 = 11.0, so 4.25 is 39%, inside the band.	-
6	Fail	MCA = 1.25 × 11.5 + 1.2 = 15.6 A. 14 AWG with a 15 A breaker is too small; 12 AWG with a 20 A breaker works if the nameplate maximum allows it.	Schematics (wire list)
7	Pass	22 of 22 lines and 31 of 31 wires match, no interference.	-
8	Fail	Hole rim is 4.9 mm from the edge; one diameter is 6.5 mm.	Geometry
9	Unknown	2 of 43 fasteners were never swept. Count it as a fail until they are.	DFM / DFA
10	Fail	Source is versioned, which is good, but vibration, defrost and the R290 charge limit are not covered and nobody has signed.	Human review

Score: 4 pass, 5 fail, 1 unknown. Decision: do not release; fix. Four of the fixes return to cheap stages (tests, wire list, geometry, sweeps). The compressor swap restarts the simulation, and check 10 needs a person, not another script. Checks 4 and 5 passed with little room to spare, so record their margins instead of celebrating them.

Real-world scenario

The bracket passes every DFM check and cannot be assembled

A design agent generates the fan-motor bracket for a heat-pump outdoor unit. The compile-time checker reports 41 rules and zero violations: 3 mm aluminium, two R6 bends, M6 clearance holes 12 mm from the edge, wall and flange rules satisfied. Fifty brackets are cut and bent. On the line, the first unit stalls: two of the four M6 screws that fix the bracket to the coil end plate sit behind the coil, and a socket with extension needs 40 mm of straight access on the screw axis while only 12 mm is free. The operators remove the coil, fit the bracket and refit the coil, adding about 20 minutes per unit.

Symptoms

DFM report: 41 rules checked, 0 violations, 0 warnings
Two of the four M6 screws cannot be reached with a socket and extension because the coil blocks the screw axis
Operators must remove and refit the coil to install the bracket, adding about 20 minutes per unit

Interview questions

screenWalk me through a systems-first AI design pipeline for a heat pump.

I start with requirements that carry units and test conditions, then generate the systems level: a P&ID for the refrigerant loop and a single-line and wiring diagram, both as graphs. Next come real components matched to each duty, and an end-to-end simulation that returns heat output, COP and current. Only then does the agent write geometry through a CAD kernel, followed by DFM and DFA checks that return diagnostics, and finally subassemblies and an assembly order. Each stage has a machine check, and failures loop back to the cheapest stage that can fix them, so an undersized compressor returns to component selection instead of surviving into 3D.

screenWhat is the difference between DFM and DFA, and why do you need both?

DFM asks whether a single part can be manufactured: bend radius, wall thickness, hole-to-edge distance and flange length against the shop's capabilities. DFA asks whether parts can be assembled: a free insertion path, tool access to every fastener, a valid order and few reorientations. They fail independently, which is why a bracket can pass every DFM rule and still be impossible to install behind a coil. I want both as compile-time checks, because anything the pipeline does not check it silently assumes.

screenWhere is AI good in hardware design, and where does it fail?

It is good at search across large catalogs, at boilerplate such as BOMs, wire lists and parametric variants, and at keeping names, units and identifiers consistent across schematic, BOM and 3D. It is weak at tolerances and fits, at tacit shop knowledge such as what a press brake can hold, at physics nobody simulated, and at mirrored or left-right geometry. It also invents plausible part numbers and datasheet values. So I use it where results can be checked mechanically and keep a human on the decisions that depend on judgement.

screenHow does an EV charging site-design engine map onto the heat-pump pipeline?

The stages are the same with different artifacts. Requirements are stalls, kW per stall and the utility service, which become a single-line diagram and a load calculation. Components are the transformer, switchboard, conductors and chargers, and the simulation checks voltage drop and load management. Geometry is the stall layout and trench routes, and the code checkers (NEC 625 and accessibility rules) play the role of DFM. The loops are also the same: an overloaded service returns to component selection, and a failed clearance returns to the layout.

deepHow would you evaluate an AI-generated design before it goes to manufacturing?

I would score it against a fixed rubric in three layers. Rule checks cover traceability, schematic completeness, real parts, layout versus schematic, DFM and DFA. Simulation covers the energy balance, performance against the spec, a COP that sits at a plausible fraction of Carnot, and electrical sizing against the minimum circuit ampacity. Human review covers what was never modelled, such as vibration, defrost and refrigerant charge limits, a prototype test plan and a named engineer who signs. I also require reproducible source, because every change should be a reviewable diff. Anything unknown counts as a fail until it is checked.

deepWhy run the checks at compile time, and what does that buy you with an LLM in the loop?

A compile-time check gives fast, deterministic feedback with exact numbers, such as a hole rim 4.9 mm from the edge against 6.5 mm required. An agent can read that, fix the geometry and rerun in seconds, which is the loop that makes generation converge instead of guess. Errors found early are cheap, since a wrong line size costs seconds in a simulator and a recall in the field. The limit is that a checker only knows the rules someone wrote, so a green report proves those rules and nothing more. I treat it as one verification layer next to simulation and human review.

Quiz

References and further reading

Where the ideas in this lesson come from, and what to read next. Books are the standard texts; papers are the original sources; standards are what employers work to.

Paperfree online
Liane Makatura et al. (2023). How Can Large Language Models Help Humans in Design and Manufacturing? arXiv 2307.14377.
Read: The whole paper: an honest audit of an LLM doing design and manufacturing tasks.
Paper
Karl D. D. Willis et al. (2021). Fusion 360 Gallery: A Dataset and Environment for Programmatic CAD Construction from Human Design Sequences. ACM Transactions on Graphics 40(4).doi:10.1145/3450626.3459818
Read: What CAD-as-a-program data looks like.
Paper
Rundi Wu, Chang Xiao and Changxi Zheng (2021). DeepCAD: A Deep Generative Network for Computer-Aided Design Models. IEEE/CVF International Conference on Computer Vision (ICCV).doi:10.1109/ICCV48922.2021.00670
Read: Generative CAD as sketch-and-extrude sequences.
Book
Geoffrey Boothroyd, Peter Dewhurst and Winston A. Knight (2011). Product Design for Manufacture and Assembly. CRC Press, 3rd edition.
Read: The DFM and DFA methods an agent should check against.
Paperfree online
Shunyu Yao et al. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. International Conference on Learning Representations (ICLR).
Read: The reason-and-act loop agents use.