How a new “Cursor for PCBs” is transforming hardware engineering from a manual slog into an agile, natural-language conversation.
- End-to-End AI Engineering: Copperhead translates natural-language product briefs into fully manufacturable KiCad files, firmware scaffolds, and structured development plans.
- Intelligent, Verified Iteration: Acting like a pair-programmer, it reads design docs, edits KiCad schematics directly, and guarantees reliability by running native ERC/DRC checks until the tools agree.
- Secure, Ecosystem-Friendly Integrations: From reusing Claude Code authentication to offering a sandboxed MCP server, Copperhead plugs into existing developer ecosystems while strictly enforcing design safety and documentation invariants.
Hardware is about to change. Forever. Over the last few years, the software industry has been radically accelerated by AI agents that can navigate, refactor, and write complex codebases. Hardware, by contrast, has remained a rigid, manual domain where changing a single component requires cascading, error-prone updates across schematics, layouts, and documentation. Enter Copperhead: an AI product-development agent built exclusively for hardware. Acting as a true “Cursor for circuit boards,” Copperhead is designed to conceptualize, document, and validate real printed circuit boards (PCBs) from a simple prompt, operating natively on existing KiCad repositories.
Copperhead bridges the massive gap between a product brief and physical manufacturing. With the copperhead createcommand, the agent executes a full pipeline from natural language. It handles the initial specification, system architecture, part selection, schematics, and first-draft layouts, ultimately yielding gerber files, a firmware scaffold, and a build plan. For existing projects, copperhead do allows developers to prompt targeted changes—like “add an external key jack” or “cut the sleep current.” The agent operates on the KiCad repository exactly the way a coding agent refactors a software codebase, reading and editing real .kicad_sch and .kicad_pcb files (s-expression text) while maintaining markdown design docs as its long-term memory.
Operating Copperhead feels remarkably like pair-programming, but the shared screen is a circuit board. The agent’s workflow is a continuous, intelligent loop. It starts by reading the design docs, ensuring it understands the overarching architecture before it touches a single wire. You then talk through the desired change, and the agent proposes the necessary parts and circuitry; you can push back and refine the concept until the reasoning holds up. Once aligned, Copperhead writes changes straight into the KiCad schematic and the design docs, enforcing identical part and net names everywhere to prevent project drift. If you change a single value, like a charge current, it propagates that edit across every document and schematic that references it. Every real decision is annotated with a one-line reason, ensuring that the next iteration doesn’t quietly undo a critical piece of logic.
What makes an AI hardware agent truly trustworthy is its strict adherence to two core invariants. First, nothing starts without a specification. Copperhead is structurally restricted from touching a KiCad file until a validated change proposal exists; every single edit is completely traceable to a documented intent. Second, nothing is considered “done” until the traditional tools agree. Every file mutation is immediately followed by a kicad-cli run. The agent reads the Electrical and Design Rule Check (ERC/DRC) errors, autonomously applies fixes, and repeats the process until the board passes native verification.
Under the hood, Copperhead is highly adaptable to modern AI developer environments. It supports models like OpenAI’s Codex, leveraging a read-only sandbox that prevents native writes while allowing native reads. Because Codex keeps session logs locally (which fall outside Copperhead’s transcript-redaction boundary), developers can easily route executables using COPPERHEAD_CODEX_PATH to maintain strict data-retention policies. For users in the Anthropic ecosystem, Copperhead natively drives Claude Code via the optional Claude Agent SDK. By simply passing --model claude-code, the agent seamlessly reuses your saved login token, meaning a Claude subscription runs Copperhead without requiring raw API keys. The CLI owns authentication securely; missing dependencies simply result in an actionable error, touching nothing.
When the design loop closes, the journey to manufacturing is rigorously protected. The copperhead export bom command generates a supplier-ready Bill of Materials deterministically. This process is entirely LLM-free and network-free. It reads exclusively from the drift-checked markdown documentation, refusing to export if the BOM ever disagrees with the schematic. Furthermore, an experimental Model Context Protocol (MCP) server ensures that host coding agents cannot blindly rewrite a KiCad schematic and bypass safety protocols. The server exposes the gated pipeline as five opaque, outcome-level tools (copperhead_check, do, sync, init, doctor). Because there is no raw file-edit tool exposed, host agents are forced to respect the spec-gating and verification loop.
By combining the fluidity of natural language iteration with the rigid validation of traditional PCB engineering, Copperhead isn’t just updating schematics. It is fundamentally rewriting the blueprint of how physical products are built, transforming hardware development into an agile, highly verifiable discipline.
