KiCad Happy
Give coding agents the tools to catch KiCad circuit, PCB, EMC, and production risks before fabrication.
CI explicitly limits permissions to contents: read, the core analyzers are described as local Python with no required packages, and the license and copyright attribution are clear. This provides substantive evidence for privilege restraint, dependency reduction, and attribution. Deductions apply because distributor APIs, datasheet downloads, GitHub comments, and installation into user skill directories create external or persistent effects without a systematic account of per-action confirmation, transmitted fields, credential storage, privacy handling, or telemetry. Cache removal, plugin disabling, and reinstall instructions offer limited recovery, but there is no transactional rollback for generated artifacts or external comments. Unknown publisher identity was not treated as suspicious or as an automatic deduction.
The README is broadly consistent about core analysis, optional SPICE engines, graceful skipping when no simulator exists, and cross-platform installation. CI covers compilation on Python 3.10 and 3.12, command help, a cache round trip, a pinned test-harness revision, and contract tests. Scores are reduced because no implementation or test results are supplied, so the broad feature claims cannot be statically confirmed; distributors, PDF sources, and simulators remain environment-dependent, while visible failure guidance is largely limited to simulation skipping and a reference to an unavailable troubleshooting document.
The material clearly addresses full and focused design reviews, EMC, SPICE, BOM work, datasheets, and fabrication readiness, with environment guidance for Claude Code, Codex, Copilot CLI, Antigravity, opencode, GitHub Actions, and standalone scripts. Eleven named skills and optional simulator fallbacks provide strong scenario and environment fit. Deductions reflect the absence of the actual SKILL.md trigger definitions, conflict resolution, and false-trigger controls; the promise that an agent can be pointed at a project and do the rest also leaves autonomy and human engineering-review boundaries imprecise.
The README has strong organization, installation and upgrade paths, RC pinning, platform notes, workflow descriptions, capability tables, and numerous input/output examples. The complete MIT text justifies full license credit. Skill names are mostly stable across sections, although the stated platform support and manual-install skill lists do not map perfectly. Claude update issues, Windows symlink constraints, SPICE fallback, and RC validation limits are documented, but there is no centralized FAQ, complete changelog, or explicit compatibility/deprecation policy. A copyright holder and GitHub issue path provide limited ownership evidence, while maintenance commitments, response responsibility, and a security-update path are unspecified.
The example outputs use severities, calculated values, risk scores, production gates, and supplier exports in directly actionable formats, strongly supporting output usability. Combining KiCad parsing, cross-domain checks, simulation, datasheets, and sourcing suggests meaningful value beyond a generic coding assistant; a dependency-free core and optional degradation reduce entry cost. Deductions apply because most effectiveness, coverage, rule-count, and success-rate claims are README assertions without supplied implementation or result sets, and the costs of APIs, simulators, human review, and erroneous advice before fabrication are not quantified.
Claims are linked internally to named scripts, guides, example reports, CI stages, a pinned harness revision, and contract-test commands, while README and CI partially corroborate major entry points. Deductions apply because the referenced guides, examples, harness contents, implementation, and actual CI results are not included, preventing independent or claim-by-claim confirmation. Many precise figures and case results are presented as factual marketing claims; although some assumptions, confidence sources, and fallback modes are identified, measured results, inference, heuristics, and illustrative output are not consistently separated.
- Before using distributor APIs, downloading datasheets, or enabling the GitHub Action, review credential scopes, transmitted fields, cache locations, logs, and external comment behavior; the supplied material defines no sensitive-data or telemetry policy.
- Do not treat EMC scores, certification suggestions, thermal estimates, or the fabrication release gate as certification or authorization to order boards. High-risk designs still require human review, original-datasheet verification, and laboratory testing.
- The claimed 44 rules, 40 detectors, 96% download success rate, and case-study precision are not substantiated by supplied implementation or test results and should be verified at the pinned revision before adoption.
- Installation and update guidance includes deleting plugin cache directories and creating global symlinks; verify exact paths and retain a recoverable backup before executing those steps.
What does this agent do, and when should you use it?
KiCad Happy is a collection of electronics-focused agent skills and pure Python 3.10+ analyzers that read KiCad 5 through 10 schematics, PCB layouts, and Gerbers. Its 11 named skills—kicad, spice, emc, datasheets, bom, digikey, mouser, lcsc, element14, jlcpcb, and pcbway—span design review, simulation, sourcing, and fabrication preparation. The analyzers parse components, nets, and board geometry, identify functional circuits, and produce severity-ranked findings covering power, signal integrity, thermal behavior, EMC, DFM, and lifecycle concerns. It can run inside Claude Code, OpenAI Codex, Google Antigravity, or opencode, as standalone Python scripts, or as a GitHub Action that reviews KiCad-related pushes and pull requests. Core static analysis does not require KiCad, Docker, or third-party Python packages, while SPICE validation and online datasheet or distributor operations require the relevant simulator, network access, or credentials.
The workflow begins by reading .kicad_sch, legacy .sch/.lib, PCB, and Gerber data. The kicad skill converts S-expression and related design files into structured component, net, copper, and subcircuit data, then calculates feedback voltages, filter cutoffs, crystal loading, power trees, trace-current limits, and thermal indicators. The emc skill applies 44 checks for ground-plane voids, decoupling, exposed interfaces, differential-pair skew, PDN impedance, crosstalk, and radiation risk, producing a risk score, priority frequency bands, and suggested near-field probe points. The spice skill generates testbenches for detected RC/LC filters, op-amp stages, dividers, feedback networks, transistor switches, and oscillators; it invokes ngspice, LTspice, or Xyce and supports Monte Carlo tolerance analysis and parameter sweeps. If no simulator is found, it skips simulation without stopping the remaining analysis. The datasheets skill downloads and verifies PDFs through DigiKey, LCSC, element14, or Mouser, then extracts pinouts, electrical limits, topology, and model data into quality-scored, per-MPN JSON caches. BOM and supplier skills audit MPN coverage, find and validate parts, and produce purchasing files plus JLCPCB or PCBWay BOM/CPL outputs. Results can be delivered as structured design reports, fabrication release-gate assessments, supplier order files, or GitHub status checks and review comments.
- A hardware engineer finishing a KiCad controller board can check regulator feedback values, missing protection, unconnected nets, and inadequate decoupling before ordering prototypes.
- A team preparing for FCC, CISPR 32, CISPR 25, or MIL-STD-461G pre-compliance can prioritize risky bands, connectors, return paths, and differential-pair problems from schematic and PCB geometry.
- An analog or power designer can have detected filters, op-amp stages, and feedback networks verified with ngspice, LTspice, or Xyce, including tolerance and what-if sweeps.
- A team moving from prototype to production can synchronize datasheets, fill MPN gaps, review component lifecycle status, and export distributor and JLCPCB/PCBWay BOM/CPL files.
- A development team maintaining KiCad files in GitHub can add automated status checks and structured PR comments whenever schematic or PCB files change.
- An engineer using Claude Code, Codex, Antigravity, or opencode can ask a focused question about a USB pair, boost-converter loop, touch input, or power sequence without requesting a full-board review.
What are this agent's strengths and limitations?
- It covers a connected hardware workflow from schematics, PCB files, and Gerbers through datasheets, BOM sourcing, supplier orders, and fabrication release checks.
- The core analyzers are dependency-free Python 3.10+ scripts that do not require KiCad or Docker and support KiCad versions 5 through 10.
- EMC analysis includes 44 checks, while SPICE supports per-part behavioral models, PCB parasitics, Monte Carlo tolerance analysis, and parameter sweeps.
- Delivery is flexible: Claude Code and Codex skills, an Antigravity plugin, opencode configuration, standalone scripts, and a GitHub Action are all documented.
- The project reports validation across more than 5,800 open-source KiCad repositories, including 6,845 schematic files, 3,498 PCB files, and over 808,000 regression assertions.
- Its documented parsing scope is KiCad; there is no evidence of equivalent direct analysis for proprietary Altium or OrCAD project formats.
- High-fidelity SPICE checks require a separate ngspice, LTspice, or Xyce installation and are skipped when none is available.
- Datasheet synchronization and sourcing need network access, and full DigiKey, Mouser, and element14 API flows require provider-specific credentials.
- The EMC output is explicitly pre-compliance analysis; the supplied evidence does not establish it as a substitute for laboratory certification or engineering sign-off.
- Analyzer upgrades may change findings: v2.2.0 specifically warns that hierarchical and bus-heavy designs can receive corrected net lists and that bare net-name suppressions should be reviewed.
How do you install or deploy this agent?
Python 3.10+ is required. In Codex, use the documented request: Use $skill-installer to install the kicad-happy skills from https://github.com/aklofas/kicad-happy. For a manual Codex installation, run:
git clone https://github.com/aklofas/kicad-happy.git
cd kicad-happy
mkdir -p ~/.codex/skills
for skill in kicad spice emc datasheets bom digikey mouser lcsc element14 jlcpcb pcbway; do ln -sf "$(pwd)/skills/$skill" ~/.codex/skills/$skill; doneFor Claude Code, run:
/plugin marketplace add aklofas/kicad-happy
/plugin install kicad-happy@kicad-happyFor Google Antigravity, run: agy plugin install https://github.com/aklofas/kicad-happy.git. For opencode, clone the repository and run opencode inside it; .opencode/opencode.json loads all 11 skills from ./skills/. Core analysis needs no pip installation, Docker, or KiCad. SPICE requires ngspice, LTspice, or Xyce. Distributor APIs can use DIGIKEY_CLIENT_ID, DIGIKEY_CLIENT_SECRET, MOUSER_SEARCH_API_KEY, and ELEMENT14_API_KEY; LCSC requires no key.
How do you use this agent?
After installation, point the agent to a local project with a request such as: Analyze my KiCad project at hardware/rev2/. Focused requests are also supported, for example: Check the two capacitive touch buttons on my PCB for routing or placement issues. To populate the datasheet cache, ask: Sync datasheets for my board at hardware/rev2/. For simulation, request: Run SPICE on everything the analyzer detected and tell me what doesn't look right; the tool auto-detects ngspice, LTspice, or Xyce. Before production, ask: Is this board ready to order? or Generate the BOM for JLCPCB assembly. For continuous review, configure the repository's GitHub Action so pushes and pull requests touching KiCad files receive a status check and structured review comment.
How does this agent compare with similar options?
Compared with Altium or OrCAD, the repository explicitly relies on KiCad's readable S-expression files to inspect components and nets without a proprietary export plugin; it does not document equivalent support for those commercial EDA formats. At the agent-runtime level, it is not tied to one coding assistant: the same skills are documented for Claude Code, OpenAI Codex, Google Antigravity, and opencode, with standalone Python and GitHub Action paths available when an interactive agent is unnecessary.