cd /news/ai-agents/fable-5-2-vs-pcb-routing-and-placing · home › topics › ai-agents › article
[ARTICLE · art-172595] src=pcbjam.com ↗ pub= topic=ai-agents verified=true sentiment=· neutral

Fable 5.2 vs. PCB routing and placing

PCBJam ran blind tests of Fable 5.2 on printed circuit board routing and placement, stripping copper from real boards and withholding the originals, and found the model produces working PCBs for small hobby boards and non-dense larger boards with fast signals, but declares dense boards too much to handle. The agent ran in a Docker container with the official KiCad 10 image, Node and Claude Code via `claude -p --model fable` with an empty config directory, blocked from GitHub, arduino.cc and Kitspace, and every board was scored out of 10 by Claude Opus 5.5 alongside scripted DRC, unconnected-net, track-length, via, corner, pair-length and skew measurements. PCBJam published every prompt, score, image and agent note in the public PCBJam/blind-pcb-runs repository and its runs-2026-11 release, and reported that giving the model the right tools substantially improved its results.

recommendation

Give a PCB-layout agent real EDA tooling and a stripped board with the original hidden, and scope it to small or non-dense boards; PCBJam found dense boards were refused outright.

more in playbook: Designing agent systems
read37 min views6 publishedNov 19, 2026
Fable 5.2 vs. PCB routing and placing
Image: source

Every recent frontier model tells us it can design and route a PCB. The latest was Fable 5.2, and OpenAI promised a decent job from Astra too. We had already spent some time with autorouters and part placement scripts for pcbjam, so we knew roughly where the hard parts are. We wanted to find out whether our time on those tools was “wasted”, or whether the claims are just marketing. We wanted to test and measure Fable’s capabilities, so we gave the model a real board with the copper removed, didn’t let it see the original, and compared what came back with what a human did.

This post goes through all of our experiments and iterations, from our own 6-key macropad to a Raspberry Pi CM4 carrier with four NVMe slots. Every run’s prompt, scores, images and the agent’s own notes are in a public repository, PCBJam/blind-pcb-runs, and the full raw output (transcripts, intermediate boards, scripts the agent wrote) is attached to its runs-2026-11 release. If you want to rerun a test, or try another model on the same boards, everything you need is there (except our helper tool, bt; we may open-source it later, and its description is in every brief if you want to build your own).

tl;dr

  • For small hobby boards it will produce a working PCB.
  • For larger boards that aren’t dense, it works, even with fast signals on them.
  • For dense boards it will tell you that it’s too much.
  • If it has the right tools, it does a much better job.
  • Check the numbers in the tables below!

The sandbox. Each run is a Docker container with the official KiCad 10 image, Node and Claude Code. The agent runs claude -p --model fable with an empty config directory, so it has no memory of earlier runs. Its only way to the internet is a proxy that refuses GitHub and its mirrors, anything with “pcbjam” in it, arduino.cc and Kitspace, which are the places the original boards live. Everything else is allowed and logged. No run tried to get around it, and no run used web search.

The input. Before a run we strip the board: tracks, vias and zones are removed. In a routing-only run the parts stay where the human put them. In a place-and-route run, a script locks the parts we want kept (connectors, mounting holes, sometimes the outline) and moves everything else into a grid below the board (in later runs all on one side; some earlier runs kept them on both). The agent gets the schematic, the netlist and a short brief: place and route this board, it should be manufacturable, write down what you changed and why. It may change design rules if it explains why. The brief never says what to watch out for. We wanted to see what it does with the kind of prompt a non-professional would write.

The reviews. Every board was checked twice. Our own scripts measure what can be measured: DRC with KiCad 10, unconnected nets, track length, vias, corners, pair lengths and skew. Then Claude Opus 5.5 reviewed every board, the human originals included, and scored placement and routing out of 10, with a list of everything a picky reviewer would circle. The scores and the harsher quotes in this post are Opus’s. They’re there so the AI runs can be compared with each other and with a known reference point. They’re not a verdict on the people who designed the originals, several of whom do this for a living and ship these boards in volume. Also, if you don’t agree on some of these, or you just want to talk about them, just hop on to our Discord, we’d be happy to hear what professionals think.

Two kinds of vias. Counting vias is the obvious way to compare layouts, and it’s misleading if you count them all together. A track via takes a signal or a power line to another layer. Lots of those means the routing kept running out of room, and every one is a small impedance bump and a hole in a plane. A ground via ties a ground pad or a ground pour to the ground plane. Fable sprinkles these over every empty area of copper, the way some designers do on purpose (it’s called via stitching). Lots of ground vias is mostly harmless. So everywhere in this post we count the two separately.

How to read the pictures. Red is the top copper and blue the bottom, with zone fills left out so the tracks show. Four- and six-layer boards also have their inner layers: the “All layers” view draws them under the outer ones in KiCad’s colors, and each inner layer has its own view, drawn the same way: tracks and vias only, no pours. “Fable’s input” is the board as the agent got it. Click any image to open it at full size.

The runs came in batches, and so did the tools #

We didn’t plan the whole study up front. We ran a batch, looked at what the agent struggled with, changed one thing and ran the next batch.

  1. No tools at all. The first runs had KiCad’s Python API,kicad-cli and whatever the agent installed. It wrote a lot of its own tooling: a track writer over pcbnew, a renderer, a DRC summary script. On our H4E2 keypad it wrote its own A* router in Python with numba, on a 0.1 mm grid, rather than routing by hand.
  2. Asking the agent. After a run we resumed the same session and asked it which tools would have made the job faster or cheaper. All five agents we asked put the same thing first: a pad-to-pad router call that returns tracks or “blocked by X at (x, y)”. They estimated it would save 25–60% of the run.
  3. Autorouters, found by themselves. On the Arduino Mega both agents went looking for Freerouting. GitHub was blocked, so they fetched it from JitPack and Maven Central, got a Java runtime from PyPI, and tried for a virtual X server from Debian’s mirror. One run routed most of the board through Freerouting in stages. The other ran it several times and threw almost all of it away because of “long detours”.
  4. An MCP server. We reran one macropad job with the open-sourceKiCAD-MCP-Server connected, Freerouting included. It has 250 tools. The agent loaded 7 and called 4: open, autoroute twice, close. It threw the autoroute result away and did the same pcbnew scripting as before. Time and cost were within 3% of the run without it. Asked why, it said the MCP keeps its own copy of the board in memory, which fights with scripts that rewrite the file, and that one-edit-per-call tools are slower than one script that writes sixty tracks.
  5. bt, a small CLI built from their answers. So we built what they asked for: a stateless command-line tool that reads the board file and answers geometry questions. What’s free around this pad, can this net get from A to B on this layer, route this net, check this batch before I write it, render this window with labels, show only the DRC errors I caused. Everybt run that finished also wrote a review of the tool, and each review became the next round of fixes. The tool itself isn’t in the public repository yet, but the description the agents got is, in every run’s brief.

The runs before bt show what the model does with nothing but KiCad. The runs after show what it does with a tool shaped by its own complaints. We’ll say which is which as we go.

Our macropad #

A 2-layer RP2040 board: 6 hot-swap keys with SK6812 LEDs, the RP2040 in a 0.4 mm-pitch QFN-56, QSPI flash, USB-C. The schematic came out of our AI-assistant tests. The placement came from our generator script plus hand tweaks, and one of us routed it by hand, without any EE training. It came out looking smart: the MCU sits on its own top-layer island, the key lines share one bus on the back, and power takes the shortest path. 27 track vias and 18 ground vias.

Routing only, placement kept. The shape is close to ours: the same top-layer island at the MCU, and the QSPI and key lines bundled about as tightly as ours (79% of the QSPI run parallel, against 81%). Its track vias are about the same as ours, 30 against 27. The difference is ground: 131 ground vias against our 18, one next to almost every ground pad. That’s the pattern on every board in this post. The real weakness is under the MCU: the bottom ground there is cut up by the 3.3 V ring and the decoupling cap pads, so the chip’s return current goes the long way round.

The USB pair isn’t length-matched or impedance-controlled. At the 12 Mbit/s the RP2040 runs USB at, that doesn’t matter, and the agent said so itself in its notes: “Fine for full-speed USB (12 Mbit/s), which is all the RP2040 does.” That was a pattern in every run. When it cut a corner, it usually knew, and wrote it down.

There are router artifacts too, little steps in a track for no visible reason (probably the handwritten A* router caused these):

Place and route. In run “a” the agent could move all the parts but keep the outline. Click “Fable’s input” above to see what it started from. It turned the RP2040 by 90° so USB, QSPI and the key pins point at what they connect to, and the MCU block landed about where ours is. 35 minutes and $12.27, the best value of any run. Opus still circled one key line that runs beside the crystal for 5 mm at 0.25 mm. The agent had noticed it too and accepted it because “key lines are static”.

In run “b” we asked for everything on the back and a smaller board. We ran this one three times: with no tools, with the MCP, and with bt.

| | No tools | KiCad MCP | bt |

|---|---|---|---|
| Time | 1:17 | 1:15 | 1:02 | 

| Cost | $25.90 | $25.22 | $20.42 | | Board | 68.15 × 38.1 mm | 61.15 × 38.1 mm | 57.15 × 38.1 mm | | Track vias / ground vias | 25 / 68 | 45 / 84 | 44 / 113 | | Placement / routing | 6 / 5.5 | 5.5 / 5 | 8 / 6 |

All three are DRC-clean with nothing unconnected. The board without tools bought its size with the power network: about 95 mm of track to the regulator, a 150 mm LED rail at 0.3 mm, and 19 separate ground islands on the back. The MCP run got smaller by squeezing the RP2040 between the key sockets, but its USB pair is 44 mm long, four times ours. The bt run is the best macropad placement we have, ours included, if size is the goal: no wing at all, and a USB lane of about 10 mm. Its price is on the top layer, which turned from a ground plane into a routing layer, and an LED enable line that goes 150 mm around three edges of the board to deliver a DC level.

Is any of this objectively worse than ours? Electrically, on this board, no. USB full speed, slow key lines and 800 kHz LED data all survive cut planes and extra vias. Ours is cleaner and probably cheaper to make, and that’s about it.

Our H4E2 keypad #

The H4E2 is a small test board from our HALE-H8E10 project: a XIAO module, four hall-effect keys read by an ADC, two encoders, a display and SK6812 LEDs. It’s the one small board where routing changes how it works. Hall sensors measure magnetic fields, and LEDs are a switching load next to them. The human rule was: analog on the bottom, LED power and data on top, and a keepout that keeps the top ground solid under the analog area.

One thing to know before comparing: we routed the H4E2 to be a small copy of the big H8E10 board, on purpose, so we could test the big board’s layout on four keys. So some of its choices are there because they’re on the big board, not because they’re best for this one. The ADC’s position and the way its lines run are the clearest example, but also, we would probably not need a GPIO extender for this size.

In the routing-only run, Fable wrote its own A* router, and it found “analog on the bottom” without being told: the hall lines are 100% bottom layer with 0 vias. It didn’t find the keepout idea, so 27 mm of analog runs within 1 mm of LED copper. Ours has 0.9 mm. When it could also place the parts, it moved the ADC between the key rows, which brought that down to 5.3 mm. It moved the problem away instead of routing around it. Both Fable boards use fewer track vias than ours (40 and 17 against 54).

So on analog, our board is still the best of the three. Opus’s review of our board found plenty to complain about elsewhere, mostly power:

  • The 5 V LED rail is 318 mm long and runs around the whole board. Every LED animation pushes current around a loop the size of the PCB, a few millimeters from sensors that measure magnetic fields. Opus estimated the effect at under one ADC step, so it works, “but by luck, not by design”.
  • The analog 3.3 V supply is 169 mm of 0.2 mm track. Opus had criticized Fable’s routing-only run for a 140 mm analog loop at 0.4 mm, and ours is longer and half as wide. Its words: “Pot, meet kettle.”
  • The display lines run on the top layer for about 55 mm, cutting the same slot in the top ground that it criticized Fable’s routing-only run for.

Next step up: a community KiCad recreation of the Mega 2560 with USB-C. Two layers, the ATmega2560 in a 0.5 mm-pitch TQFP-100, a QFN-32 USB bridge, 66 footprints. Worth knowing: under KiCad 10’s default rules the human board shows 505 clearance errors, so it’s a layout reference, not a gold standard.

Routing only is the Freerouting run. 2:22, $18.61, every net routed and DRC-clean. The agent laid ground first, hand-scripted USB-C, power and the resonator, then fed Freerouting in stages: critical nets, then single-layer buses, then power, then the rest. Its own verdict: “The signal routing is autorouter quality, not hand quality.” This is the one board where Fable’s track vias are far above the human’s, 185 against 101, and one analog input changes layer 9 times.

Place and route is the opposite. The agent placed the MCU so its ports face the double-row header and then scripted almost all the copper itself. It’s the most orderly copper in the study: ports fan to the header in 45° lanes, and the 16 ADC lines run as one bus on the bottom. 104 track vias, about the same as the human’s 101. It’s also expensive at $50.60, and the MCU’s four supply pins share a 0.3 mm link under the package. Opus: “that’s how you get a board that resets when a relay clicks.”

The lesson from the Mega: routing around someone else’s placement is much harder than routing your own. That held for every board after it.

These three are real products with four or six layers:

  • Olimex ESP32-PoE-ISO (Rev.O, CERN-OHL): an ESP32 module, an Ethernet PHY, isolated 802.3af PoE with a 3 kV barrier, USB serial, microSD and a LiPo charger. 147 footprints on 4 layers.
  • Glasgow revC3 (0BSD): an iCE40 FPGA in a 0.8 mm BGA-121, a Cypress FX2 USB 2.0 high-speed bridge, 16 level shifters and an LVDS port. 269 footprints on 4 layers.
  • OrangeCrab r0.2.1 (CERN-OHL and MIT): a Lattice ECP5 in a 0.5 mm-pitch BGA with DDR3L, on a 50.8 × 22.9 mm Feather board with 6 layers.

All three ran with bt. Here’s why they’re so much harder than the boards above.

Inner layers are supposed to stay planes. On a 2-layer board, a track that has nowhere to go can usually hop to the other side. On a 4-layer board, the inner layers are the ground and power planes that every fast signal uses as its return path. Using them as overflow lanes is legal for DRC and bad for the board, and the agents did it whenever they ran out of room. Use the In1 and In2 buttons below to see it.

BGAs need an ordered escape. Getting 100+ balls out from under a BGA is a puzzle about the order in which nets leave the package. Our router routed one net at a time and had no notion of “these N nets leave in this order and arrive in that order”. The agents wrote their own lane generators for this, which worked but took hours.

One net at a time fills the channels. In the words of one agent: “Each call is locally sensible, but 60 calls in a row fill every channel with long diagonals and box in the last 15–20 nets.” That’s how most of the failed runs ended: the important nets done well, the last few dozen boring ones walled in.

ESP32-PoE-ISO: none of the three finished #

Routing only got the parts that matter right. The PoE chain, the Ethernet pairs routed so nothing crosses at the protection diodes, RMII as fixed lanes, USB, and an unbroken ground plane with no tracks on it. Then it stopped with 43 links open, mostly long GPIO nets that the router couldn’t thread through its own earlier tracks. It lost about 75 minutes to router runs it had to throw away, and it never found Olimex’s isolation barrier, which is drawn on a user layer, so it made up its own 1.4 mm rule. Look at its In2: about 250 mm of track hops through the 3.3 V plane.

Place and route, as small as possible had the best judgment up front: the RJ45 and the antenna at opposite ends, headers kept breadboard-spaced, and its own 3 mm isolation rule, checked through every layer. It chose 30 × 74.7 mm, 18% less area than Olimex’s 28 × 98 mm. Then the bottom side under the module got too dense to finish, and it handed over 39 open links with a clear note: “The board must not be ordered as it is. … I would rather hand over an honest partial than a file that looks finished.”

Place and route, Olimex’s outline found the barrier on the user layer and used it for both sides of the isolation, which is exactly what a reviewer would want. But it put the module 1.5 mm lower than Olimex did to clear the SD card, which pushed 8 module pads into the mounting-hole keepouts, and then it ran out of channels: 48 open links, including all four Ethernet pair nets. Its In1 ground plane carries about 90 track segments from the last router pass.

Glasgow revC3: the first dense board it finished #

The routing-only run finished every net in 2:24 for $53.93, and it worked like a designer would. One level-shifter cell, generated by its own script and repeated 16 times. A non-crossing 45° fan for the LVDS pairs. Solid ground on In1, power islands on In2 sized from where the bottom-side caps sit. About half the copper came from its own Python generators, checked with bt before being written. Its notes list every compromise, down to each via in a pad. Its track vias are close to the human’s, 323 against 293; most of the difference in the total is ground.

Opus didn’t let it off easy. There’s 13 mm of 3.3 V track through the ground plane, and a dozen signals hop through the 3.3 V plane, the 48 MHz FX2 clock among them (see In2). The LVDS pairs aren’t length-tuned and have no impedance target, where the human’s are tuned. And to fit, it loosened the rules to 0.125 mm clearance and 0.1 mm necks. The human board fits at 0.15/0.15 because it uses smaller vias in the BGA, so that wasn’t necessary.

The place-and-route run made a placement better than the obvious one. It put the FX2 right beside the USB-C connector, so the high-speed USB pair is 3.5 mm long and straight, and the FPGA level with the FX2, so the bus between them is about 2 mm. In the original it crosses the board diagonally. It routed every fast net, then hit the 4-hour limit before the slow ones and the ground pours: 73 links open. A 4-layer board with 17 open ground links has return paths that are only theoretical.

OrangeCrab: the widest gap #

This is the hardest board in the study. Fable routed the whole DDR3 interface on a 0.5 mm-pitch BGA, which is a real achievement for a blind agent. It took three attempts, all in its progress log. The third used escape vias placed by hand and a bus router it wrote itself, because our router walled off neighboring nets.

The rest didn’t happen. There’s no length tuning, with up to 7 mm of spread inside a byte lane. The FPGA’s supply balls are unconnected, so the board can’t power up, and USB data is open. Tracks are 0.09 mm almost everywhere because our router couldn’t change width along a route. It also kept the bottom under the DDR free of parts so the silkscreen crab logo stays intact, which put the DDR decoupling 2–3 mm from the balls. Opus: “The crab logo is pristine.”

One handicap here was our fault. The brief promised the schematic, but our prep script dropped the KiCad 5 schematic files, so the agent worked from the netlist and the pinouts it knew.

The question we cared about most after the dense boards: give it a board where the speed matters, say nothing about it, and see whether it treats the fast pairs differently. We picked two PCIe boards that aren’t very dense.

M.2 to PCIe x4 adapter (Antmicro) #

A passive adapter: an M.2 key-M card edge to a PCIe x4 socket, four lanes and the reference clock, 20 footprints. Antmicro does this for a living. One caveat: the project already had Antmicro’s 85 Ω net class for the pairs, which we left in, so the agent wasn’t fully blind to “these are special”.

22 minutes and $6.93, the cheapest run of the study, and the first board where Fable matched a professional on the part that matters. The pairs arrive at the socket in the opposite order, with P and N mirrored, so every pair must change layer. Fable made the layer change itself mirror-symmetric, so P and N swap inside the bend and come out the same length. Zero skew on all 9 pairs, with no serpentines, which we checked with our own script. Both inner layers are solid ground, every layer change has its own ground return via, and it correctly left out AC-coupling caps because the host and the card carry them.

The price is vias: 95 track vias against Antmicro’s 40, and 123 ground vias against 52, most of them a fence along the pairs. Opus: “A via fence with a board attached.”

CM4 NVMe NAS #

A community board by will127534: a Raspberry Pi CM4 carrier with an ASMedia PCIe switch feeding four M.2 NVMe slots, Gigabit Ethernet, two USB-C ports, an RP2040 fan controller and six buck regulators. 298 footprints on 4 layers. This project has no hint at all that the pairs are special: one default net class, no differential-pair rules. This was the real test.

Routing only. It noticed. Without being told, it changed the stack-up (outer layers 0.21 mm above their planes, “which is what makes ~90 Ω pairs possible at a sane width”), added a differential-pair net class, kept In1 as unbroken ground, and put the In2 power islands only where no pair runs above them. Its pair topology matches the human’s via for via. It didn’t length-tune; skew is up to 1.3 mm, about 9 ps on a 200 ps bit at the CM4’s PCIe Gen 2, which survives, and it said so. 2:51 and $34.64.

Place and route. This is the best PCIe in the study, the human’s included. It moved the switch right up to the sockets and turned it 180°, so the ports come out in socket order with the upstream port facing the CM4. Ports 1–3 are 26–52 mm long, against 76–101 mm on the original. All 15 pairs run on the top layer over solid ground, and only the five that pass through their AC-coupling caps change layer: 5 vias on the P lines against the original’s 26. Data pairs are skew-compensated to under 0.01 mm. It also flagged the assumption we should check: parts under the SSDs only fit with the tall 4.2 mm M.2 socket.

Opus’s summary: “The PCIe is a 9 and the rest is autorouter weather.” A dozen slow nets that cross the board (reset, boot, UART, fan PWM, the thermistors) change layer 8–12 times and cut the bottom ground pour into pieces. That’s where its 353 track vias come from, not the PCIe. The thermistor lines are analog and run long distances next to digital ones, and the agent’s advice is to filter in firmware. That’s a software fix for a layout problem.

The human board is better at power: wide pours where Fable has a 2.5 mm 12 V bus with fingers and thin strips to each SSD. It’s also one of the few boards where Fable used fewer ground vias than the human.

Every run above happened once, so how much of it is luck? To find out, we gave Fable the same routing job twice, plus a placement run, on a board none of the earlier runs had seen. SparkFun’s IoT RedBoard ESP32-P4 came out in 2026. It’s a 4-layer, 68.6 × 58.4 mm Arduino-shaped board with an ESP32-P4 in a 104-pin QFN at 0.35 mm pitch, an ESP32-C5 radio module, MIPI camera and display connectors, USB 2.0 high-speed, a LiPo charger and an SD card. We removed the project’s MIPI and USB net classes first, so nothing told the agent that those pairs are special. All three runs used a newer round of bt, which can length-tune pairs.

The two routing runs agree on the decisions that matter. Both finished with nothing unconnected and no new DRC errors. Both kept In1 as unbroken ground with no tracks on it. Both added a ~90 Ω USB class and a ~100 Ω MIPI class on their own, calculated from the stack-up. Both worked out that with this placement the camera and display pairs can’t all stay on one layer, and both moved the crossing pairs to the bottom layer through vias placed between the processor’s pin row and its center pad. Both hand-scripted every pair and used the router only for the slow nets. Both ran the 1.1 V core supply as tracks on In2, and both left I²C and reset as long, via-heavy router output. They listed nearly the same weaknesses in their notes.

They differ in the details. Run a made In2 a 3.3 V plane with a ground patch under the pairs; run b made it ground almost everywhere, with 3.3 V only under the processor and regulators, which gives the bottom-layer pairs a better reference. Run a got the length tuner to match five of the six MIPI pairs to 0.01 mm; run b left 0.5–2.6 mm of skew and called its tuning bumps “very small wiggles”. Run b also put about 20 ground vias inside small pads, which needs plugged vias at the fab. That’s about the spread you’d get from two people doing the same job: same plan, different execution.

For comparison, by our count SparkFun’s board isn’t length-tuned either: up to 4.9 mm on the display clock pair. At the P4’s MIPI rates that’s fine, and Fable said the same about its own leftover skew. SparkFun also put 140 mm of tracks on In2, so neither side kept that layer clean. The fair summary is that Fable’s best routing run is close to SparkFun’s, a bit more via-hungry (246 track vias against 164) and better tuned. Place and route. The floor plan is good. The processor is turned so the MIPI, flash and USB pins face their connectors, and the radio module sits on the right edge with its antenna flush with the board edge. The buck converter’s power loop is short, and the bulky SOT-223 regulator went to the bottom side under the SD socket. The routing isn’t. Its via pattern around the processor (vias inside the pin ring and a second row just outside) fenced off the bottom layer, so the router sent 428 mm of signals over the In2 power layer and cut both supply planes into pieces. The agent then stitched the pieces back together with thin tracks until DRC passed. It ran out of time before length tuning and wrote: “I would not order this board as it is.” It’s the right call, and the same failure we saw on the ESP32 and OrangeCrab boards: once the fan-out is wrong, every later step pays for it.

All three runs also hit the same tool bug: SparkFun stores the board outline inside a footprint, which bt couldn’t read (fixed in the next round), so every clearance check failed until the agents moved the outline out of the way and back again at the end. Each one worked around it on its own; it cost up to an hour per run.

The first thing an EE will point at on a layout is a 90° corner, and the second is a corner sharper than that. A sharp inside corner can trap etchant during manufacturing (an “acid trap”), and on fast signals a corner is a small impedance step. At the speeds on most of these boards, a 90° corner does nothing measurable electrically. But it’s the clearest sign of a hurried or machine-made layout, and reviewers notice it first.

We counted every place where two tracks of the same net meet at 90°, at a sharper angle, or where a track turns back on itself (under 10°). That last kind isn’t a corner at all: it’s overlapping copper or a short dead-end stub, usually left behind by a router or a script.

Board Run 90° Sharper than 90° Turns back on itself
Macropad human 9 4 0
route only 19 4 0
place + route (a) 22 3 0
b, no tools / MCP / bt 8 / 9 / 17 5 / 6 / 8 1 / 0 / 11
H4E2 human 11 1 3
route only 32 28 11
place + route 23 1 0
Mega human 14 4 0
route only (Freerouting) 73 5 0
place + route 9 1 0
ESP32-PoE-ISO human 118 57 41
route / smallest / outline kept 26 / 34 / 24 11 / 8 / 4 1 / 2 / 0
Glasgow human 73 17 11
route only 95 27 34
place + route 116 52 11
OrangeCrab human 58 21 61
place + route 25 36 215
M.2 adapter human 7 0 1
place + route 0 2 0
CM4 NAS human 26 6 4
route only 46 48 46
place + route 94 38 13
RedBoard ESP32-P4 human 29 9 0
route only (a / b) 14 / 13 21 / 20 11 / 9
place + route 28 16 9

The unfinished ESP32 runs have less copper than Olimex’s board, so their low counts mean little. On finished boards the picture is mixed. When Fable scripted the copper itself (Mega place and route, the M.2 adapter, the macropad without tools), it has as few right angles as the human or fewer. When a router did the work (the Mega’s Freerouting run, our A*-routed H4E2, the slow nets on Glasgow and the CM4), right angles go up 2–5×. The 215 turn-backs on the OrangeCrab are router debris: short stubs that double back where a route was ripped up and redone. They pass DRC, but you’d clean them up before ordering.

Most of Opus’s complaints in this post are about signal integrity (SI) and electromagnetic interference (EMI), not DRC. A board can pass every rule check and still fail on the bench or at certification. The patterns that showed up again and again:

  • Return paths. Current goes out on a track and comes back on the plane under it. Cut the plane (a track across it, a power island, a row of vias) and the return current detours around the cut. The loop it makes is an antenna. This is why using inner planes as overflow lanes, as the ESP32 and OrangeCrab runs did, is worse than it looks.
  • Pair skew and stubs. On fast differential pairs, P and N have to arrive at the same time, and every via stub reflects a little. At 12 Mbit/s USB none of this matters. At PCIe or DDR3 speeds it’s the difference between a link that trains and one that doesn’t.
  • Hot loops. A buck regulator switches amps in nanoseconds. The loop from its input cap through the switch and back must be tiny. On the CM4, each buck’s input-cap ground and IC ground sit on opposite sides, so that loop closes through the ground plane under the PCIe pairs.
  • Analog next to switching loads. The H4E2’s hall sensors next to LED rails, the CM4’s thermistors next to digital lines.

What Fable did well: on the fast parts, it reasoned like an SI engineer. It found impedance control on its own, protected reference planes under pairs, and placed parts so pairs could be short and straight. What it did badly: everything it considered unimportant got autorouter treatment, and slow nets cutting planes is exactly how a board with perfect PCIe fails an EMC test.

All runs used our Claude subscription. The costs below are what Claude Code reported at API prices. 21 runs took about 50 hours of agent time and would have cost about $706 at API prices. Where we measured it, about three quarters of a run’s cost was thinking. The cheapest run was the M.2 adapter: 22 minutes, $6.93. The most expensive were the Mega’s place-and-route run and the dense 4- and 6-layer boards, at $43–60, and one of those (Glasgow) hit our time limit before Claude Code could report a cost, so its ≈$60 is estimated from the token counts. The times include an emulated amd64 container on a Mac, so tool calls were slower than they would be on a Linux box.

bt didn’t make the small runs dramatically cheaper ($20.42 against $25.90 on the macropad), but it changed what the agent did with its time: fewer homemade tools and more checking before writing.

Track length and vias are compared with the human board for the same project. Outline is the bounding box; the percentage is only shown where we asked for a smaller board. All scores are Opus 5.5’s, out of 10, for every board including the human ones. A routing-only run kept the human placement, so it has no placement score of its own. Unfinished runs have less copper because they didn’t finish, so their percentages say little.

Run Task Time Cost Track mm Track vias Ground vias Outline mm Place Route Result
Our macropad (hobbyist) human 879 27 18 89.15 × 38.1 7 7.5
| macropad-top | route | 0:49 | $14.64 | 1,060 (+21%) | 30 (+11%) | 131 (+628%) | 89.15 × 38.1 | – | 6 | finished | 
| macropad-a | place + route | 0:35 | $12.27 | 881 (+0%) | 26 (−4%) | 112 (+522%) | 89.15 × 38.1 | 7 | 6.5 | finished | 
| macropad-b | place + route, shrink | 1:17 | $25.90 | 1,094 (+24%) | 25 (−7%) | 68 (+278%) | 68.15 × 38.1 (−24%) | 6 | 5.5 | finished | 
| macropad-b-mcp | place + route, shrink, MCP | 1:15 | $25.22 | 1,138 (+29%) | 45 (+67%) | 84 (+367%) | 61.15 × 38.1 (−31%) | 5.5 | 5 | finished | 
| macropad-b-bt | place + route, shrink, bt | 1:02 | $20.42 | 1,143 (+30%) | 44 (+63%) | 113 (+528%) | 57.15 × 38.1 (−36%) | 8 | 6 | finished | 

| Our H4E2 (hobbyist) | human | | | 2,258 | 54 | 31 | 86 × 77.68 | 7 | 7 | |

| h4e2 | route | 0:52 | $16.42 | 1,965 (−13%) | 40 (−26%) | 202 (+552%) | 86 × 77.68 | – | 6 | finished | 
| h4e2-place | place + route | 1:02 | $21.67 | 2,202 (−2%) | 17 (−69%) | 212 (+584%) | 86 × 77.68 | 7 | 6.5 | finished | 

| Mega USB-C recreation (community) | human | | | 5,017 | 101 | 53 | 101.6 × 53.34 | 8 | 6.5 | |

| mega-route | route | 2:22 | $18.61 | 4,987 (−1%) | 185 (+83%) | 157 (+196%) | 101.6 × 53.34 | – | 4.5 | finished | 
| mega-place | place + route | 2:47 | $50.60 | 5,488 (+9%) | 104 (+3%) | 92 (+74%) | 101.6 × 53.34 | 7 | 7 | finished | 

| Olimex ESP32-PoE-ISO (pro) | human | | | 4,982 | 214 | 113 | 28 × 98.15 | 8.5 | 8 | |

| esp32-route-bt | route, bt | 2:40 | $30.74 | 2,489 (−50%) | 142 (−34%) | 43 (−62%) | 28 × 98.15 | – | 4 | 43 open | 
| esp32-small-bt | place + route, shrink, bt | 3:01 | $45.55 | 1,999 (−60%) | 137 (−36%) | 9 (−92%) | 74.7 × 30 (−18%) | 7 | 3 | 39 open | 
| esp32-iso-bt | place + route, bt | 4:16 | $44.43 | 2,658 (−47%) | 172 (−20%) | 75 (−34%) | 28 × 98.15 | 6.5 | 3 | 48 open, 21 DRC | 

| Glasgow revC3 (pro team) | human | | | 4,437 | 293 | 123 | 80 × 49 | 8.5 | 8.5 | |

| glasgow-route-bt | route, bt | 2:24 | $53.93 | 4,130 (−7%) | 323 (+10%) | 253 (+106%) | 80 × 49 | – | 6.5 | finished | 
| glasgow-place-bt | place + route, bt | 4:00 | ≈$60 | 3,525 (−21%) | 259 (−12%) | 95 (−23%) | 80 × 49 | 7.5 | 4 | 73 open, time limit | 

| OrangeCrab (experienced designer) | human | | | 2,848 | 300 | 141 | 50.8 × 22.86 | 9 | 9 | | | orangecrab-bt | place + route, bt | 4:38 | $52.14 | 2,384 (−16%) | 345 (+15%) | 109 (−23%) | 50.8 × 22.86 | 6.5 | 4 | 70 open | | Antmicro M.2 adapter (pro) | human | | | 1,186 | 40 | 52 | 80.01 × 33.73 | 8.5 | 8.5 | | | m2-place-bt | place + route, bt | 0:22 | $6.93 | 886 (−25%) | 95 (+138%) | 123 (+137%) | 80.01 × 33.73 | 8 | 8 | finished | | CM4 NVMe NAS (experienced hobbyist) | human | | | 7,769 | 247 | 802 | 147.4 × 91 | 7 | 7.5 | |

| cm4-route-bt | route, bt | 2:51 | $34.64 | 7,585 (−2%) | 212 (−14%) | 541 (−33%) | 147.4 × 91 | – | 7.5 | finished | 
| cm4-place-bt | place + route, bt | 2:55 | $33.95 | 7,029 (−10%) | 353 (+43%) | 379 (−53%) | 147.4 × 91 | 8.5 | 7 | finished | 

| SparkFun IoT RedBoard ESP32-P4 (pro) | human | | | 3,377 | 164 | 135 | 68.58 × 58.42 | 8.5 | 8 | |

| redboard-route-bt-a | route, bt | 2:55 | $49.55 | 3,547 (+5%) | 246 (+50%) | 133 (−1%) | 68.58 × 58.42 | – | 7 | finished | 
| redboard-route-bt-b | route, bt | 3:17 | $43.37 | 3,842 (+14%) | 270 (+65%) | 153 (+13%) | 68.58 × 58.42 | – | 6.5 | finished | 
| redboard-place-bt | place + route, bt | 4:45 | $44.87 | 3,814 (+13%) | 320 (+95%) | 102 (−24%) | 68.58 × 58.42 | 7.5 | 5 | finished | 

“Finished” means 0 DRC errors that weren’t already in the input and nothing unconnected. The CM4 routing run has one open item, the USB-C shield pads, which the netlist leaves unconnected on purpose.

Look at the two via columns together. On 8 of the 16 finished runs, Fable used at most 11% more track vias than the human, and often fewer. The exceptions are two macropad runs (44–45 against 27, small numbers), the Mega routing-only run (Freerouting), the M.2 adapter, the CM4 place-and-route run, where the slow nets went to the router, and all three RedBoard runs (50–95% more), where the vias around the 0.35 mm QFN add up. The ground via column is where the 3–7× numbers are, and those are the harmless kind.

PCB layout isn’t solved by AI. Fable 5.2 still treats slow nets as an afterthought, cuts planes it should protect, and on dense BGA boards it runs out of room or time. You wouldn’t send any of the unfinished boards to a fab, and the agent told us so every time.

But look at what it did with a prompt a hobbyist could write. It found impedance control on a board that never mentioned it, beat the human PCIe routing on the CM4, matched Antmicro on the M.2 adapter for $7, and was honest about every shortcut it took. Compared to where this was half a year ago, the gap is closing day by day.

We’ll keep running these as the models and our tools change. Since the first runs, bt has learned length tuning, and the RedBoard runs show it working when the agent has room for it. If you run the tests with another model or another tool, we’d love to see the results: open an issue or a pull request on the runs repository, or post them on Discord.

── more in #ai-agents 4 stories · sorted by recency
── more on @fable 5.2 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/fable-5-2-vs-pcb-rou…] indexed:0 read:37min 2026-11-19 · —