kicad schematic

    1

    Generate and validate KiCad 10 schematics as Python code with automated linting and integrated part sourcing.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    kicad schematic

    Example session with this skill installed

    Create a new KiCad 10 project named 'sensor_node' with a power regulator sheet using a TPS7A0533. Find the part in the Promelec catalog and add it to the sheet with a GND connection.

    • Read your context and instructions
    • Compiled the kicad schematic
    • Generated the UI component

    I have initialized the 'sensor_node' project and generated the power regulation sheet. I found the TPS7A0533PDBZR in the local Promelec catalog (Price: 50, Stock > 300) and placed it with proper grid snapping and a GND power symbol.

    Generated Schematic Code

    import sys
    sys.path.insert(0, "scripts")
    from schlib import Project
    
    # Initialize Project
    pr = Project("sensor_node", outdir="./build", title="Sensor Node", rev="A")
    
    # Create Power Sheet
    pw = pr.sheet("power.kicad_sch", "Power Regulator", (30, 50), (50.8, 25.4),
                  pins=[("VBAT", "input"), ("+3V3", "output")])
    
    # Add Component (Sourced from Promelec)
    u1 = pw.sym("U1", "Regulator_Linear:TPS7A0533PDBZ", (100, 60),
                value="TPS7A0533", footprint="Package_TO_SOT_SMD:SOT-23-3",
                fields={
                    "MPN": "TPS7A0533PDBZR",
                    "Manufacturer": "TI",
                    "Supplier": "Promelec",
                    "Price": "50",
                    "Note": "Low Iq regulator for battery life"
                })
    
    # Wiring and Ground
    pw.wire(u1.pin("1"), (80, 60))
    pw.label((80, 60), "VBAT")
    pw.power("GND", (100, 80))
    
    # Validate and Save
    validation_results = pr.check()
    pr.save()
    print(f"Validation: {validation_results}")
    

    Next steps

    1. Run python3 scripts/check.py build/sensor_node.kicad_sch to generate visual previews.
    2. Open build/power.png to verify the U1 label placement doesn't overlap wires.
    3. Run scripts/bomgen.py to export the initial procurement list.

    power.png

    TSX · React component

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop wrestling with KiCad's manual GUI for complex hierarchical designs. This skill treats schematic capture as code, generating .kicad_sch files via Python to ensure perfect grid alignment, consistent naming, and git-friendly diffs.

    What it does

    • Schematic generation creates KiCad 10 schematics using a standalone Python DSL without external dependencies.
    • Automated linting catches overlapping labels, disconnected wires, and off-grid components using SVG-based geometry analysis.
    • Component sourcing integrates with Promelec local catalogs to find in-stock parts with real-time pricing and MPN data.
    • BOM management generates formatted bills of materials including total project costs and supplier-specific part numbers.
    • ERC & Validation executes hierarchical checks to ensure sheet pins match internal labels and clears all Electrical Rules Checks.

    How it works

    1. Define the project by initializing a Project object and defining top-level hierarchical blocks in Python.
    2. Populate sheets by adding symbols, wires, labels, and power rails using specific coordinates or pin-referencing methods.
    3. Run the check pipeline using check.py to compile the schematic, run the linter, and generate visual PNG previews.
    4. Audit visual gates by reviewing the generated PNGs for readability issues that automated tools might miss, like text layout or signal flow direction.

    Frameworks & tools

    Specifically designed for KiCad 10.0.4 (format 20260306) and Python 3.13. It operates natively without kiutils or sexpdata, utilizing internal scripts for S-expression parsing and font modeling.

    Why this beats prompting it yourself

    Generic LLMs struggle with the precise S-expression syntax of KiCad 10 and often place components off-grid. This skill uses a hardened library that guarantees 1.27mm grid snapping and automated coordinate calculation for pins, ensuring the resulting file actually opens in KiCad without errors.

    Use cases

    • Generating complex multi-sheet industrial controller schematics with strict naming conventions.
    • Converting a napkin-sketch component list into a fully sourced BOM with active stock checks.
    • Refactoring an existing schematic to fix "annotation errors" or broken hierarchical links that the KiCad GUI won't explain.

    Known limitations

    Does not perform PCB layout or routing. Local catalog data must be manually updated if older than 30 days. Requires kicad-cli for high-precision geometry linting.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.

    No PCB layout/routing. Local catalog requires manual re-parsing via scripts. Linter precision drops if kicad-cli is missing. Optimized for KiCad 10.0.4 only.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed today

    • Free with an Agensi account

    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Environment Variables
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill uses a Python DSL to generate KiCad 10 schematics as code, ensuring perfect 1.27mm grid alignment and automated linting that prevents the common 'off-grid' and 'disconnected wire' errors associated with manual GUI entry or raw LLM prompting.

    The skill is specifically optimized for KiCad 10.0.4 (format 20260306) and requires Python 3.13; it also requires the `kicad-cli` to be installed on your system for high-precision geometry linting and ERC validation.

    Yes, it features integrated Promelec local catalog support to pull real-time pricing and MPN data, allowing it to generate a formatted BOM alongside the schematic files.

    You receive the full Python-based schematic generation library, the automated linting suite (including SVG-based geometry analysis), and the Promelec catalog integration scripts.

    While the skill handles complex hierarchical schematic generation and ERC validation, it does not perform PCB layout, trace routing, or footprint placement.

    New in APIs & Backend

    Free