---
title: "He makes one PCB a year. That's exactly often enough to forget the workflow"
locale: "en"
url: "https://irz.fr/en/articles/kicad-helpers-procedural-memory-en"
markdown_url: "https://irz.fr/en/articles/kicad-helpers-procedural-memory-en.md"
category: "tech"
tags: ["KiCad", "PCB", "electronics", "automation", "JLCPCB", "LLM", "workflow"]
published_at: "2026-08-22T09:26:00.000Z"
author: "Manon Girard"
translation: "https://irz.fr/fr/articles/kicad-helpers-procedural-memory-fr.md"
---

# He makes one PCB a year. That's exactly often enough to forget the workflow

Kevin Lynagh is not automating PCB design. His KiCad helpers automate the awkward moment when he has to remember how his entire workflow worked last time.

Kevin Lynagh knows how to design a circuit board, which is precisely why beginning the next one can be so annoying.

He began playing with electronics through Arduino in 2010, designed his first PCB in 2015 and has made roughly a dozen since then, with a burst of strange mechanical keyboards during the pandemic.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/) Add the work together and he has hundreds of hours of experience; spread it across a decade and the rhythm comes out near **one PCB a year**.

The rhythm leaves him in an awkward middle ground: far too experienced to begin from zero, but infrequent enough for the procedure to fall out of working memory between projects.

A new board therefore starts with a little archaeology: he has to recover the export path, remember how the DXF was replaced cleanly, find the JLCPCB parts data again and reconstruct which checks were mandatory before fabrication. Lynagh compares the feeling to doing taxes, another annual process where old notes meet an interface that has quietly moved things around since the last encounter.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)

Armed with a coding agent, he turned that reorientation cost into a repository of scripts called **Kevin's KiCad Helpers**.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)[2](https://github.com/lynaghk/kevins-kicad-helpers)

What the scripts leave alone matters more than the usual AI framing would suggest: circuit design stays with Lynagh, while the material he already knows but no longer wants to reconstruct every twelve months becomes executable.

## Once a year

Software skill is usually described with the tidy beginner/expert split, although infrequent expert work sits awkwardly between those categories and behaves like neither.

The concepts can remain familiar enough to judge whether a result is absurd and remember why an operation exists, while the operational details leak away: an exact command, an export order, a filename convention, some checkbox buried in a dialog, the small safety check that was supposedly impossible to forget again.

Human memory, unfortunately, makes a poor build system.

For Lynagh, much of the friction sits at tool boundaries rather than in electronics. Mechanical geometry lives in Autodesk Inventor because he wants its constraint solver and references to other objects; board outlines and mounting holes then travel into KiCad as DXF.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)[2](https://github.com/lynaghk/kevins-kicad-helpers)

KiCad can import DXF through the GUI, but that route has no convenient way to replace the previous imported geometry during iteration. His helper gives the filename meaning instead: `panel_Edge.Cuts.dxf` identifies the `panel` group and the `Edge.Cuts` layer, old geometry carrying the same ID is deleted, and a watcher repeats the import whenever the source file changes.[2](https://github.com/lynaghk/kevins-kicad-helpers)

Pair that with a watcher exporting from mechanical CAD and the boundary nearly disappears.

> **Most of the forgetting lives between tools**
> Diagram showing the transitions from mechanical CAD to KiCad, checks and fabrication outputs.
> - Mechanical CAD
> - DXF
> - KiCad
> - Checks
> - Fab
> - The helpers stabilize imports, parts lookup, checks, exports and version provenance.
> Design stays in specialist tools. Automation concentrates on the seams of the workflow.

Nothing here resembles a “make my PCB” button: mechanical design remains in Inventor, electrical design remains in KiCad, and the script removes the ritual needed to keep those worlds synchronized.

## The build

The clearest expression of the idea is `kkh build`, because it turns a collection of remembered pre-fabrication chores into one repeatable entry point.

Run it inside a Git repository and it discovers `*.kicad_pro` projects, performs checks, then creates an output directory beside every board.[2](https://github.com/lynaghk/kevins-kicad-helpers) The directory name records the date and Git revision and also marks a working tree containing uncommitted changes.

Inside are the BOM, placement data, netlist, Gerber archive, full STEP model, simplified STEP model and PDFs for the schematic and board faces.[2](https://github.com/lynaghk/kevins-kicad-helpers)

Besides making fabrication convenient, the naming answers a question hardware asks months later with unusual force: **which exact source snapshot produced the board now sitting on my desk?**

The build version is exposed to KiCad as a variable, so `${KKH_VERSION_DATE}` can be placed on silkscreen and end up in the actual Gerbers.[2](https://github.com/lynaghk/kevins-kicad-helpers)

> **One build, three kinds of memory**
> - ERC, DRC and custom checks run without a mental checklist.: Procedure
> - BOM, placements, Gerbers, STEP and PDFs leave together.: Outputs
> - Date + Git revision + dirty state identify the source snapshot.: Provenance
> - The build version can be printed onto PCB silkscreen.: Object
> The script does not choose the circuit. It makes the chosen circuit reproducible.

Lynagh has a less abstract reason for caring about the checks: he describes sending a PCB to fabrication after forgetting ERC and later discovering that some IC pins had simply never been connected.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)

The current implementation runs **ERC against the schematic**, then **DRC against the PCB** with schematic-parity checking before building outputs.[2](https://github.com/lynaghk/kevins-kicad-helpers) One sentence in the README happens to swap those acronyms in prose; the code runs the right check on the right artifact. It is an accidental little demonstration of the whole thesis: remembered descriptions drift, executable rules are harder to misremember.

## Invariants

Lynagh has added rules beyond KiCad's general-purpose checks.

His schematic analyzer generates a netlist and loads component relationships and custom properties into a DataScript graph database.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)[2](https://github.com/lynaghk/kevins-kicad-helpers) That makes project-specific queries possible.

An `i2c` property on schematic instances lets the analyzer print the address map and fail when an address belongs to distinct chips. `max_mA` properties can be totalled for current budgeting. Another query calculates explicit capacitance on `VCC` or `VBUS` and raises an error when the total reaches the 10 µF ceiling Lynagh wants to enforce in his USB designs.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)[2](https://github.com/lynaghk/kevins-kicad-helpers)

> **Turn an omission into an error**
> - Put I²C address, maximum current or another fact in the schematic.: Annotate
> - Generate the netlist and load relationships into a graph database.: Extract
> - Calculate address collisions, current or total capacitance.: Check
> - Fail the build before a bad board reaches fabrication.: Stop
> Procedural memory becomes a property of the project rather than only its author.

These rules are deliberately personal. Lynagh has considered a small language for declaring invariants in schematic text boxes, but the current checks are still partly hardcoded around his own needs.[2](https://github.com/lynaghk/kevins-kicad-helpers)

A generic checklist can say “remember ERC”, but a personal automation layer can encode the much stranger rule that actually matters to its author: bypass capacitors keep accumulating, so calculate the VBUS total every time and stop the build before an electrical habit becomes an expensive physical mistake.

## Local database

Parts selection carries another annual reorientation cost.

Lynagh has his boards assembled by JLCPCB, so stock, package, price and current catalogue availability matter while he designs.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/) Repeating web searches is slow and last year's useful component may no longer be the sensible choice.

His downloader builds a local indexed SQLite database for this purpose. The July newsletter described an earlier version based on CDFER's daily JLCPCB database.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/) On **August 21**, the repository changed the downloader to use the `jlcparts` project instead; current comments describe a roughly 5.7 GB split SQLite source which is transformed into a smaller query-oriented database with normalized tables.[2](https://github.com/lynaghk/kevins-kicad-helpers)[3](https://github.com/yaqwsx/jlcparts)

Resistors, capacitors and inductors receive numeric SI-unit columns, so `100nF` and `0.1µF` can become the same numerical value and ordinary SQL can ask for capacitance and voltage ranges.[2](https://github.com/lynaghk/kevins-kicad-helpers)

Lynagh browses that database directly, but also shows an LLM agent being pointed at the local file and asked for a short list of H-bridge candidates meeting voltage, stock and price constraints.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)[2](https://github.com/lynaghk/kevins-kicad-helpers)

> **The agent does not know today's stock**
> - Ask a model to remember which JLCPCB components are available now.: Bad role
> - Let it query a fresh local database under explicit project constraints.: Better role
> - Downloaded structured catalogue, not model memory.: Source
> - The designer still chooses the final component and trade-off.: Decision
> Here the LLM is an interface to controlled data rather than an authority about the catalogue.

Among the agent uses in the project, this is one of the least theatrical and most convincing: the model is not expected to remember a supplier catalogue, only to interrogate a fresh catalogue that has actually been downloaded.

## Not a product

Turning the repository into “the new AI suite for electronics” would badly misread its author.

The README calls the helpers unashamedly vibe-coded, says they work for Lynagh and are shared in case somebody else finds them useful, then narrows the environment to **KiCad 10**, macOS, Debian sandboxes for his agents and JLCPCB-oriented fabrication.[2](https://github.com/lynaghk/kevins-kicad-helpers) The code is MIT licensed, but the project makes little effort to pretend it is a universal EDA layer.

For this use case, refusing universality is an advantage because it leaves room for rules that would look absurd in a general-purpose EDA product.

A personal tool can encode details no general product would prioritize: Lynagh's DXF filenames, his capacitance budget, his chosen assembler, or the fact that Windows CAD in a VM on his M1 MacBook Air suffers when a KiCad STEP file models every pin of every chip as an individual solid.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)[2](https://github.com/lynaghk/kevins-kicad-helpers) His STEP helper consequently replaces components with bounding boxes when all he needs is mechanical clearance checking.

The best abstraction does not always serve a million people. Sometimes it lets one person reopen a project eleven months later without having to become their former self first.

## Compile forgetting

The coding agent matters to this story, just not in the usual way.

Lynagh did not ask it to become the electrical engineer. It lowered the cost of writing small, oddly personal scripts that might otherwise have remained notes, repeated rituals or things he kept promising to automate later.[1](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)

The durable output is the repository rather than the chat that helped produce it.

The repository distributes memory across several small mechanisms: one command knows the fabrication outputs, a watcher knows which DXF geometry to replace, the database knows that 100 nF and 0.1 µF are comparable values, and a check knows that an I²C collision should block the build. Those rules remain after the conversational context disappears and after Lynagh has, quite normally, forgotten the details that made him write them.

Procedural memory survives daily repetition quite well; annual work behaves more like a cache with an aggressive expiration policy.

Kevin’s KiCad Helpers treats that expiration as a software boundary rather than a personal failure.

Automating the design would remove decisions from the designer, while **automating the restart gives him more time to make them.**

## References

1. [Kevin Lynagh, KiCad helpers and caliper improvements, July 12 2026](https://kevinlynagh.com/newsletter/2026_07_kevins_kicad_helpers/)
2. [Kevin Lynagh, Kevin's KiCad Helpers, GitHub repository](https://github.com/lynaghk/kevins-kicad-helpers)
3. [yaqwsx/jlcparts, parametric JLCPCB parts database](https://github.com/yaqwsx/jlcparts)