New guides and project ideas on X: Follow @3DeltaD

Some links here are RunPod referral links: we may earn credits if you sign up. It costs you nothing extra. Details

What can I build? / Project guides

Design a circuit board

A small LED board, a sensor breakout (a tiny board that makes one chip easy to wire up), a simple adapter. Free open-source tools can check a design and export the files a board maker needs, and your AI assistant can do much of the typing. You still have to check the result yourself before anyone manufactures it.

The honest short version

Designing a circuit board needs no GPU. The tools in this guide are ordinary CPU programs, and we found nothing in their documentation that uses a GPU, so a rented GPU adds nothing here. Yes, a site about rented GPUs is telling you not to rent one. A laptop is enough. A small CPU pod (a rented computer with no GPU) can help if you only have an iPad or a weak laptop, but it is optional. Your AI assistant is good at the mechanical parts (scripts, checks, exports) and poor at knowing whether a board will actually work. In one 2026 benchmark the best setup scored 4.58% on functional checks [26]. You must review the board yourself.

Hand-inked anime illustration of a builder with sunglasses soldering a circuit board under a desk lamp.

1. Pick the tools

A few words first. A schematic is the circuit diagram, and a netlist is the list of what connects to what. The layout is the physical board: where the parts sit and how copper traces join them. Drawing those traces is called routing. A footprint is the pattern of copper pads that one part solders onto. Gerbers are the files a board maker (a "fab") builds from, one per layer. A BOM is the parts list. Headless means run from the command line, with no window open.

ToolLicenceWhat it does from the command lineHow mature
KiCad (kicad-cli)GPL-3.0 [1]Runs the schematic check (ERC) and board check (DRC), and exports Gerbers, drill files, component positions, a bill of materials (BOM), SVG, PDF and a 3D render. Its command list has no routing or auto-placement command [3].Active. Version 10.0.8 was released within the last 60 days, with patch releases every 1 to 2 months through 2026 [2].
SKiDL (Python)MIT [5]Describe the circuit as Python. Writes netlists, a BOM and KiCad schematics, and has an electrical rules check. Its generate_pcb() step needs KiCad installed [4]. Layout is left to the layout tool.Version 3.0.0 uploaded within the last 60 days; supports KiCad 5 to 10 [6].
atopile (ato)MIT [7]A small description language. ato build solves the design, picks parts and updates a KiCad layout file. Placing and routing is still done in KiCad.Pre-release. Its docs say it is under heavy development and you may hit rough edges. Its latest stable-tagged GitHub release is v0.12.5 (released earlier this year); newer tags are pre-releases. The package on PyPI needs Python 3.14 [8][9].
tscircuit (TypeScript)MIT [10]Describe the board in TypeScript, preview it in a browser, export Gerbers, pick-and-place and BOM files, and export to KiCad with tsci export [11]. You set part positions by hand; the team says auto-layout and an autorouter are still being built. We could not confirm it runs fully headless on a server.Very active, but its version number (0.0.3192) points to continuous releases rather than a stable 1.0.
Freerouting (autorouter)GPL-3.0 [12]Reads a Specctra DSN file and saves a routed session file, e.g. java -jar freerouting.jar -de MyBoard.dsn -do MyBoard.ses. Needs a Java runtime. The router is single-threaded [13]. KiCad can use it through a plugin in the PCB editor.Release v2.5.0 within the last 60 days. The maintainer says he spends about 4 hours a week on it, and the API is beta. Routed boards still need your review.
ngspiceBSD-3-Clause [14]Circuit simulation in batch mode, e.g. ngspice -b -o result.log circuit.cir [15]. KiCad uses it as its simulation engine. It simulates only the circuit and part models you give it; it does not check layout, footprints, heat or whether a model matches the real part.Version 47, released within the last 6 months (per Wikipedia).

Our suggestion: start with KiCad alone. Draw a very small board, run the checks from the command line, and export the files. Add SKiDL, Freerouting or ngspice later if you want them. atopile and tscircuit are interesting, but they are newer or unfinished, and we have not tested them.

Install notes. These matter mostly to whoever does the installing, which is usually your assistant. Ubuntu 24.04's own package list carries KiCad 7.0.11 [19], much older than the 10.x documentation. The KiCad team publishes a package archive for 10.0 that has Ubuntu 24.04 builds [20]. KiCad also publishes Docker images meant for kicad-cli; it says using the graphical interface through Docker is not supported [21]. KiCad's older Python scripting interface (pcbnew) is deprecated, and its replacement is meant to control a running copy of KiCad [17][18]. So checks and exports with kicad-cli are the solid part of an automated flow; scripted board edits are the least certain part. Use the pcb export gerbers command; the older singular export gerber was deprecated in KiCad 9 [16].

2. Do you need a pod?

A pod is RunPod's name for a computer you rent. A CPU pod has no GPU; a GPU pod has one.

Pods are billed per second [23]. We have not run this guide's steps on a pod ourselves yet (see section 8).

3. What AI can and cannot do

Can usually do: install tools, write and run kicad-cli commands, read ERC and DRC reports, fix reported errors, regenerate outputs, write SKiDL, atopile or tscircuit code from a plain description, draft a parts list and a checklist, and explain a DRC message in plain words.

Cannot be trusted to: know that a footprint matches the real part, or that a symbol's pin numbers match the datasheet; judge power design, analog behaviour, heat, radio noise or antennas; see fine detail in a board image; know today's price, stock or fab quote (it must not invent them); or know your enclosure and how you will assemble the board.

The evidence. EDA Bench (ICML 2026 listing) tested AI agents on 35 tasks taken from open-hardware projects. The strongest setup scored 4.58% on the functional checks. It produced complete KiCad projects for 21 of the 35 tasks but failed most of the functional checks. The authors conclude that "parseable or plausible PCB artifacts are not necessarily electrically functional artifacts." [26] A separate study, PCEval, found language models do much worse on physical breadboard layout than on logical circuits, with pin conflicts the most frequent physical error. That is breadboards and Arduino rather than PCBs, so it is only indirect evidence [27]. Models change quickly, and these numbers will not transfer exactly to the assistant you use.

What a clean ERC/DRC does and does not mean. KiCad describes ERC as detecting incorrect and missing connections [29] and DRC as detecting design-rule violations such as clearance and minimum width [30]. A clean report means the connections and spacing match the rules you set. It does not prove the board works. You can also set individual checks to "Ignore" in the project, so "0 errors" can hide things.

A human must check, before any order:

  1. Every part's symbol pins against its datasheet.
  2. Every footprint against the datasheet's land pattern. Print the board at 1:1 on paper and lay the real parts on it.
  3. Polarity and pin 1 for diodes, LEDs, electrolytic capacitors, ICs and connectors.
  4. Power: current per trace, regulator limits and any battery connection.
  5. The ERC and DRC results, read by you, including which checks were ignored.
  6. The Gerber files, opened in a separate Gerber viewer. JLCPCB itself recommends cross-checking with a third-party viewer: outline continuous, holes aligned, silkscreen as expected [28].
  7. The fab's own preview and quote, and the assembly files if you order assembly.
  8. Mechanical fit: board size, mounting holes and connector positions.

4. From zero to a first board

  1. Pick a very small first board, such as an LED with a resistor and a 2-pin header. No mains voltage, no batteries.
  2. Decide where to work: your own computer (install KiCad 10) or a CPU pod (section 5). Do not start a pod unless you need one.
  3. Describe the board in plain English and have your AI assistant list every part with its datasheet pinout and footprint before it draws anything.
  4. Have it generate the schematic and board, then run ERC and DRC from the command line. Fix, rerun.
  5. Export images (SVG or PNG) and look at the board yourself.
  6. Optional: autoroute with Freerouting, then rerun DRC and review the routing.
  7. Review by hand using the list in section 3: pins against datasheets, footprints printed 1:1, polarity, power, outline.
  8. Export Gerbers, drill file, position file and BOM. Zip them and download them to your own device.
  9. Open the Gerbers in a separate viewer. Get a quote on your chosen fab's own website, and check the fab's preview.
  10. Order only after you have reviewed everything. For a first board, order the smallest quantity.
  11. If you used a pod: download your files first, then terminate the pod, and check the pod list shows nothing running.

5. If you use a pod: what to set up

Stop is not terminate. RunPod's documented storage charges [23]:

StorageRunning podStopped pod
Container disk$0.10 per GB per monthNot charged, but erased when the pod stops
Volume disk (not available on CPU pods)$0.10 per GB per month$0.20 per GB per month
Network volume$0.07 per GB per month (under 1 TB)$0.07 per GB per month

A stopped pod can still bill for a volume disk, and RunPod's guidance is to terminate rather than stop to end all charges [33]. Terminating deletes the disk [34]. What exactly happens to a stopped CPU pod that has no network volume is something we have not tested, so the simple rule is: download the files, then terminate.

6. Prompts to give your AI assistant

Paste the first box at the start of every conversation, then use the numbered prompts. Replace the parts in [brackets]. Every prompt tells the assistant to ask before spending money and to shut things down afterwards. Keep that rule.

Paste this first: the ground rules

Rules for this session: (1) Never create, start, resize or restart anything that costs money, and never create an account, without first telling me what it is, the hourly price and the total I could be charged, and getting my explicit "yes". (2) Do not invent prices, stock levels, part numbers or quotes. If you do not know, say "unknown" and tell me where to look. (3) Do not claim a board is correct. Say what was checked and what was not. (4) When we finish, list the files to download, wait until I confirm I have them, then ask me to confirm before stopping or terminating the pod. Remind me that terminating ends billing and deletes the disk.

You should get: an acknowledgement of the four rules. Check: the first time it wants to start anything that costs money, it asks you first.

Prompt 1: set up the tools

You have a shell on a fresh RunPod CPU pod (Ubuntu 24.04). Install KiCad 10 from the official KiCad team package archive (ppa:kicad/kicad-10.0-releases), plus ngspice and Python 3 with pip. Install a Java runtime only if I ask for Freerouting. Before installing anything, tell me what you plan to install and how much disk it needs, and ask me before anything that costs money. Then show the output of `kicad-cli --version`, `ngspice -v`, and `python3 -c "import pcbnew"`. If a step fails, show me the exact error and what you tried. Do not change anything except these installs and files in the project folder.

You should get: a working kicad-cli (version 10.0.x) and ngspice, with an honest report of whether the Python pcbnew module imports. Check: you can see the real version strings in the output. If import pcbnew fails, accept that rather than letting the assistant hide it.

Prompt 2: design a simple board from a plain description

Design a small board in KiCad, as a project folder `led-board/`. Spec: powered from a 5 V USB connection, one power LED with a series resistor sized for about 5 mA, a 2-pin header for 5 V and GND, two M3 mounting holes, board about 30 x 20 mm, two layers. Use only parts and footprints from KiCad's standard libraries. Before drawing, give me a table of each part: reference, value, symbol, footprint, and the datasheet or library page you used for the pin numbers. Show your calculation for the resistor, with the LED forward voltage you assumed and where that number came from. Stop and ask me if a number is unknown. Do not make mains-voltage or battery circuits. Ask me before anything that costs money.

You should get: project files (.kicad_pro, .kicad_sch, .kicad_pcb) and a parts table. Check: confirm the LED's anode and cathode and the resistor value yourself, then run the checks in Prompt 4 and look at an exported image.

Prompt 3: review an existing KiCad project

Review the KiCad project in `~/project/`. Do not modify any file. Run `kicad-cli sch erc` and `kicad-cli pcb drc` with `--exit-code-violations`, and show me the full reports. Then list every footprint with its reference, value and footprint name, and every net with fewer than two connections. Flag anything that looks like a pin-number mismatch, reversed polarity, a missing decoupling capacitor, or a trace carrying more current than its width suggests, and for each flag say how sure you are. Finish with a list of things you cannot check without the datasheets, and ask me for those datasheets. Ask me before anything that costs money.

You should get: a read-only report with the raw ERC and DRC output and a list of questions. Check: the project files are unchanged (compare timestamps), and you read the raw reports yourself, not only the summary.

Prompt 4: run ERC and DRC and fix what is safe to fix

In `led-board/`, run the schematic ERC and the board DRC from the command line with `--exit-code-violations`. Save the reports. Fix only violations that are clearly mechanical (for example silkscreen overlap or a missing board outline) and tell me each change. For anything electrical, do not fix it silently: explain it and ask me. Rerun until the exit code is 0, or until only items you have explained to me remain. Tell me whether any checks were ignored or set to "ignore" in the project settings. Ask me before anything that costs money.

You should get: ERC and DRC reports before and after, with a change log. Check: exit code 0 from both commands, and open the project's rule settings (or have the assistant print them) to see that nothing was switched off. Remember that a clean report does not prove the board works.

Prompt 5: check footprints against datasheets

For every footprint on the board in `led-board/`, create a 1:1 scale PDF of the footprints (a real-size printout I can place parts on), using `kicad-cli pcb export pdf`. For each part, give me the exact datasheet link or library entry name for its land pattern, and list the pad pitch, pad size and pin 1 position you used. If you cannot cite a source for a dimension, mark it UNVERIFIED. I will print the PDF at 100% and check the real parts. Ask me before anything that costs money.

You should get: a printable PDF and a table of dimensions with sources. Check: print at 100% (not "fit to page"), measure the printout with a ruler or calipers, and lay the real components on the paper.

Prompt 6: generate the files a board maker needs

In `led-board/`, generate the fabrication files with `kicad-cli`: Gerbers for all used layers, drill files, and a component position file; also export a BOM from the schematic. Put them in `fab/`, and make `led-board-fab.zip`. Check `kicad-cli pcb export gerbers --help` for the correct options for my KiCad version rather than guessing. List every file and its layer. Then ask me which fab I use and ask for their file requirements instead of guessing. Ask me before anything that costs money. When we are done, remind me to download the zip and to terminate the pod.

You should get: a fab/ folder and a zip with one file per layer, a drill file, a position file and a BOM. Check: open the Gerbers in a separate third-party viewer, confirm the outline is a closed shape, holes line up with pads and silkscreen is readable, and compare the file list with the fab's stated requirements.

Prompt 7: estimate the cost

Estimate what this project costs me. Part 1, RunPod: using only the hourly rate I give you ([paste the hourly price shown in the RunPod Summary panel here]) and the time we have used so far, compute the compute cost, and add the container disk charge at $0.10 per GB per month for the disk size I chose. Show the arithmetic. Part 2, board and parts: do NOT guess prices. Tell me the board size, number of layers and quantity, give me the BOM as a table, and tell me which fab quote page and which parts-supplier page I should check myself. Part 3: list the other things that could cost money (shipping, assembly, stencil, import tax) and mark each "unknown". Do not start or change anything that costs money.

You should get: a pod cost computed from your own numbers and a checklist for the board cost you get yourself. Check: redo the arithmetic, compare with RunPod's Billing page, and get the board quote from the fab's own site.

Prompt 8: wrap up and stop paying

We are finished. List every file in `led-board/` and `fab/` that I should download, with sizes. Zip them into one file and tell me how to download it from this pod (the Jupyter file browser, or whichever method we set up). Wait for me to say I have downloaded and opened it. Then tell me exactly what terminating this pod will delete, and ask me to confirm. After I confirm, terminate the pod (not just stop it) if you have permission, or give me the exact console steps. Finally, check that no pod or network volume from this session is still running or billing, and tell me what you found.

You should get: one zip downloaded to your device, then the pod terminated. Check: the RunPod pods page lists no pod from this session, the network volumes page shows no volume you did not mean to keep, and the Billing page shows the final charge.

7. Keep it safe

  • Never order a board you have not reviewed. Complete, plausible-looking projects were mostly not functional in the benchmark above [26]. Footprint and pin mistakes are the common failure, so check footprints at 1:1 and pins against the manufacturer's datasheet, not your assistant's memory.
  • Mains voltage is not a beginner project. Safe spacing for mains circuits comes from safety standards, not from generic board rules. One summary notes that IPC-2221 is a functional spacing guide and not a safety requirement, and that published figures conflict between web sources, so treat any number your assistant gives you as unverified [38]. Mains boards need review by someone qualified.
  • Lithium batteries are not a beginner project either. Adafruit's guide describes lithium-ion and lithium-polymer cells as powerful but not inherently safe, recommends protected cells, and warns that misuse can hurt you or your property. Battery University says lithium-ion packs require a protection circuit [39]. Do not let your assistant choose a charger or protection design without you checking the datasheets.
  • Do not claim certification (CE, FCC, UL). Nothing in this guide provides it.
  • Do not let your assistant invent prices, stock or quotes. Get them from the fab and parts-supplier pages.
  • A pod is not a vault. Its public web addresses have no login, and a browser desktop may have none either. Set a password, do not leave a desktop running unattended, and keep your own copy of anything you need. RunPod says pods are not designed for long-term storage of critical data [23].
  • You pay while it runs. A forgotten pod keeps billing. Terminate when finished and check the pod list.
  • Never paste your RunPod key or card details into a chat tool or a file.

8. What we have not tested yet

This guide is built from documentation, release pages and a benchmark paper, not from a finished board of our own. So far we have read a great deal and soldered nothing. Nothing we read shows a board built, made and powered up with this exact set of tools. Before we call anything proven, these still need a real hands-on test:

When we run these, we will publish the measurements with the date, the hardware and the bill.

Next: get it made

A board maker turns your files into real boards. These are places people commonly use. We earn nothing from these links, and we have not ordered from them ourselves. Prices change, so get the price on each maker's own quote page. Some public reviews (Trustpilot, read within the last 30 days) of the two biggest, JLCPCB and PCBWay, mention refund and shipping problems, so start with a small order.

What to have ready

Before you order

Want a pod for the browser-only route?

Make a RunPod account and add a small balance such as $10, or paste this into your AI assistant: Read agents.runpod.io and set up Runpod for me. Then use Prompt 1 above. Check the price per hour in the console before you deploy.

Referral link: we may earn credits if you sign up.

Create a RunPod account

Sources

  1. KiCad source mirror (license GPL-3.0 and others): github.com/KiCad/kicad-source-mirror
  2. KiCad release tags: gitlab.com/kicad/code/kicad
  3. KiCad 10.0 command-line reference: docs.kicad.org/10.0/en/cli
  4. SKiDL documentation: devbisme.github.io/skidl
  5. SKiDL repository (MIT): github.com/devbisme/skidl
  6. SKiDL on PyPI (version 3.0.0): pypi.org/pypi/skidl
  7. atopile repository (MIT): github.com/atopile/atopile
  8. atopile releases: github.com/atopile/atopile/releases
  9. atopile documentation and PyPI listing: docs.atopile.io, pypi.org/pypi/atopile
  10. tscircuit repository (MIT): github.com/tscircuit/tscircuit
  11. tscircuit documentation: docs.tscircuit.com
  12. Freerouting repository (GPL-3.0, README and releases): github.com/freerouting/freerouting
  13. Freerouting command-line arguments: github.com/freerouting/freerouting (docs). KiCad integration: integrations.md
  14. ngspice (license and version, per Wikipedia): en.wikipedia.org/wiki/Ngspice. Download page: ngspice.sourceforge.io/download
  15. ngspice tutorial (batch mode): ngspice.sourceforge.io/ngspice-tutorial
  16. KiCad 9.0 command-line manual (the export gerber deprecation): docs.kicad.org/9.0/en/cli
  17. KiCad developer docs, pcbnew Python bindings (deprecated): dev-docs.kicad.org
  18. KiCad IPC API, and an article on using it in CI (written against KiCad 9.0.0): dev-docs.kicad.org (IPC API), adamws.github.io
  19. Ubuntu 24.04 package list entry for KiCad (7.0.11): packages.ubuntu.com/noble/kicad
  20. KiCad 10.0 releases package archive (Ubuntu 24.04 build 10.0.8): launchpad.net/~kicad
  21. KiCad Docker images (for kicad-cli; GUI not supported): kicad.org/download/docker
  22. RunPod docs, CPU pods (concept description from the API reference): docs.runpod.io/api-reference-v2/overview
  23. RunPod docs, Pod pricing and storage: docs.runpod.io/pods/pricing
  24. RunPod catalog and official public template list, read through RunPod's API tools within the last 30 days (RTX 3090 rates; template ids, images and ports). This is RunPod catalog data, not a public page.
  25. RunPod docs, Get started (account steps, two-factor authentication, deploy Summary panel with cost per hour): docs.runpod.io/get-started
  26. EDA Bench, ICML 2026 listing (abstract): icml.cc/virtual/2026/77908
  27. PCEval, language models and physical circuit layout: arxiv.org/html/2601.02404
  28. JLCPCB, how to generate Gerber and drill files in KiCad: jlcpcb.com/help
  29. KiCad 10.0 schematic editor manual (ERC): docs.kicad.org/10.0/en/eeschema
  30. KiCad 10.0 PCB editor manual (DRC): docs.kicad.org/10.0/en/pcbnew
  31. RunPod docs, Connect to a pod (web terminal, JupyterLab, SSH): docs.runpod.io/pods/connect-to-a-pod
  32. RunPod docs, Expose ports (public proxy address, 100-second timeout, readiness): docs.runpod.io/pods/configuration/expose-ports
  33. RunPod docs, Manage pods (billing after stop versus terminate): docs.runpod.io/pods/manage-pods
  34. RunPod docs, Storage types (volume disk and network volume lifecycle): docs.runpod.io/pods/storage/types
  35. RunPod docs, Transfer files (scp and rsync): docs.runpod.io/pods/storage/transfer-files
  36. RunPod docs, runpodctl send: docs.runpod.io/runpodctl/reference/runpodctl-send
  37. linuxserver.io, KiCad in a browser desktop (no login by default, passwordless sudo): docs.linuxserver.io/images/docker-kicad
  38. Summaries of clearance and creepage for high-voltage boards (vendor and blog pages, not the standards themselves): byte-lab.com, vse.com
  39. Adafruit, lithium-ion and lithium-polymer batteries: learn.adafruit.com. Battery University, making lithium-ion safe: batteryuniversity.com

Licence, version and rate information was read within the last 30 days and can change; check each page before you rely on it. GPU rates are RunPod on-demand rates from its API. Product names belong to their owners and are used only to describe what they are.