Verification
A check that measures itself.
Every hardware team checks a board before it orders it. The checks list rule violations but nobody knows how often they are wrong or what they miss. PCBKit measures its own checks on real faults people shipped and publishes the numbers.
Why boards respin
Most respins come from data no tool checks.
We read 732 real fixes in the histories of open hardware projects: a board people made, found broken and fixed in the next revision. About 70 % were the part’s own data, not the copper.
35%
a footprint that does not match the part that was bought
19%
a pad left unconnected
18%
two pins swapped
Real faults
Real faults found at KiCad’s rate or better, with a tenth of its false alarms.
We collected 462 defects people shipped in public KiCad projects and fixed in the next revision and ran every checker a team can run today on both revisions. A checker finds a defect when it names it on the broken board and stops naming it on the fixed one; a judge that does not know which tool spoke decides whether the finding states the defect.
| Checker | Reads | Found, set 1 (140) | Found, set 2 (322) | Fixed board still flagged |
|---|---|---|---|---|
| PCBKit | board and schematic | 17.9 % | 8.4 % | 4.3 % / 3.7 % |
| KiCad 10 DRC + ERC + schematic parity | project, schematic, rules | 9.3 % | 6.8 % | 55.0 % / 51.9 % |
| An open-source KiCad review action | schematic and board | 0.0 % | 0.6 % | 10.0 % / 9.9 % |
| An LLM netlist review (Claude Sonnet, low effort) | parts and netlist | 4.3 % | 4.7 % | 34.3 % / 35.7 % |
The honest part. All of these checkers together find 16–21 % of real respin faults: most are invisible to every check a team runs today, ours included. That is the problem we work on and it is why we publish the number. No one else in this market publishes one.
5.7 %
of 702 findings were false on boards nobody tuned the checks on, judged blind by a separate team (35.7 % four rounds earlier)
Blind
a new check’s findings are marked unconfirmed until it clears a blind round on boards nobody tuned it on
1
verdict, built by one implementation that the app, the CLI, the agents and the CI gate all run
The verdict
A verdict in levels, each with what it judged.
A board is verified to the last level that passes with every level before it. Each level says how much of the board it actually judged, so a pass that judged nothing says so.
- 01
languagethe design file parses and its statements agree
- 02
wiringpins driven, supplies and grounds, polarity, mating connectors, reset and USB conventions
- 03
ratingsevery part against its ratings: voltage, current, power, temperature
- 04
intentthe board against the requirements its design states
- 05
layoutgeometry under the board’s own rules: clearances, shorts, courtyards, holes, thermals, silkscreen
- 06
readycan it be ordered: the fab’s capability, holes, vias in pads, exports, parts
Review with the evidence, decide in the design.
- Each finding opens its evidence: the stress against its limit, the facts it rests on with their source and grade, the parts and nets on its path and the fix.
- A waiver is a line in the design with its reason, kept in every report under “waived by the project”, never dropped. A waiver that waives nothing is itself a warning.
- Proofs speak at once. A finding that rests only on stated facts, with the arithmetic re-derived, is an error without probation.
CI gate · public
Every commit, checked.
pcbkit-io/verify runs PCBKit’s check on any KiCad repository on every push and before every order and fails the change when the board does not reach the level you require. It writes one report: the verdict per level, what each level judged, what you waived and every finding.
- Reproducible. The same files and the same release give the same report, digest for digest: a GitHub Actions runner and a GitLab job gave identical digests on three public boards.
- Pinned. Each version of the action pins a CLI release (now 2026.10.31); the report names every file and the binary by SHA-256.
- Your files untouched. The check runs on a copy, on the runner. GitHub, GitLab or any CI with Python.
# .github/workflows/board.yml
on: [push, pull_request]
jobs:
verify:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: pcbkit-io/verify@v0
with:
project: hardware/main-board
require: layout # language | wiring | ratings | intent | layout | readyPart certificates
Footprints checked against the maker’s drawing.
The biggest cause of respins is a land pattern that does not match the part that arrives. PCBKit reads the dimensions from the maker’s drawing and certifies each footprint and pin table against it. A small checker that shares no code with PCBKit re-checks the certificates.
905/1,230
parts of our board registry certified against their makers’ drawings
0
of the defects we planted in those parts on purpose were certified
Firmware at every corner
The program checked on its own board, hot and cold.
A board with a processor is not done until its program does what it is for. The design says what that is (an LED blinks, the console prints, the screen shows a picture) and the lab runs the real firmware on models of the board’s own chips at −40 °C, 85 °C and both ends of every supply. A build of such a board ends decided only when it passes.
39/39
processor boards of the registry meet their expectations at every corner
22
display boards checked against the picture their screen must show
The order record
What the fab gets is what was checked.
One archive, one digest
An order exports the fab archive once and freezes it by SHA-256 with its part certificates and library versions. A reorder sends the same bytes.
Read back before it goes
PCBKit reads its own Gerber and drill files back and compares them with the board: copper layers and outline. A mismatch stops the hand-over.
The fab’s reading too
Where a fab’s own pre-review reads the archive, a reading that differs from the board stops the order. You still choose and pay on the fab’s page.
Honest limits
What a pass does not say.
A pass means: on these exact files, this exact binary found no error up to the level you asked for. It is evidence, not proof. It does not judge footprints against makers’ drawings unless the design carries part certificates, it does not replace a lab for emissions, immunity or safety marks and on a KiCad board without a PCBKit design several levels have little to judge. Boards written in the PCBKit language state their intent, so their levels judge far more.