Schemy lets an electrical engineer edit a generated circuit drawing in KiCad, then turns that manual change back into a proposed code edit. Its new importer recognizes changed parts, values, footprints, connections, and net names. The engineer approves the proposal before Schemy rebuilds the drawing.
That return trip changes the role of a computer-aided design (CAD) file. A schematic can become an output that a team rebuilds from structured source without turning the graphical editor into read-only glass. Engineers can still move a part or fix a connection in KiCad. The generator has to understand the edit, preserve it in source, and produce the same electrical design on the next run.
We think this is the point where code-defined electronics starts moving beyond specialist tools. Generating a first schematic has been possible for years. Keeping generated source, a familiar editor, firmware configuration, and mechanical models consistent through ordinary changes has been the hard part. Several projects in the past month now treat that consistency as something software can check.
The edit can come home
Most generated hardware designs have had a one-way door. A script writes a schematic or board, an electrical engineer opens it, and the two versions begin to drift. The engineer can avoid manual edits and live within the generator's limits, or make the edit and risk losing it the next time the script runs.
Schemy attacks that problem with stable identifiers. It places identifiers in the generated KiCad file, asks KiCad's command-line program for the updated netlist, the machine-readable list of parts and connections, and matches the edited parts and connections back to its circuit model. A change it understands becomes a proposal. A symbol replacement or reference edit that it can't interpret gets reported instead of guessed.
Bringup takes a wider approach. In its prototype, changing a firmware pin or dragging a board edge starts the affected electrical, mechanical, and firmware jobs. The system records the edit, refuses a save made against an old revision, and reports changes its design data can't represent. Its measured examples finished in 21 and 96 seconds. Those are small demonstrations, but they show the right behavior: a person can work in the tool they know, and the rest of the product catches up automatically.
The same pattern now reaches the boundaries around the board. Fusible reads the board netlist and generates a Zephyr devicetree overlay, the file that tells embedded software which chips and pins exist. It derives facts such as an address selected by pins tied high or low. When the schematic doesn't contain enough information, it leaves the device disabled and says what is missing. Hammerola rebuilds the current three-dimensional board model during every mechanical build and refuses a committed generated copy that could go stale.
These tools are making one electrical description feed the drawing, firmware wiring, and enclosure check. A pin swap can update all three, or fail where the information is incomplete, before a prototype reaches the bench.
KiCad made generated files checkable
This shift is happening now because KiCad has become useful as an automated judge as well as an editor. Its documented text formats cover schematics, boards, symbols, and footprints. Its command-line interface can run electrical and board-rule checks, export netlists and bills of materials, render boards, and produce fabrication and mechanical files without someone clicking through menus. Its interprocess communication interface lets outside software control a running KiCad instance through structured messages.
Text output alone isn't enough. A generated file can be syntactically valid, open cleanly, and still connect the wrong pins. Hassassin's round-trip test imports and exports 16 KiCad projects, then compares both the netlist and KiCad's electrical warnings. That checks whether the wires still mean the same thing. OpenPlayer, an earlier example from October, builds a KiCad schematic from a Python netlist and leaves an ordinary drawing that engineers can inspect.
Larger code-first systems have been preparing this market for longer. atopile uses a declarative electronics language to select parts, enforce equations and tolerances, update KiCad layout, and produce manufacturing data. A commercial system turns requirements and manufacturing rules into Python, then generates schematics and board structures and sends high-frequency designs into Ansys High Frequency Structure Simulator (HFSS). The recent smaller projects matter because they are filling the less glamorous gaps around those compilers: import, identity, equivalence checks, edit reconciliation, and links to firmware and mechanics.
Three years ago, a generator often had to parse an undocumented design file, automate a graphical application, and invent its own correctness check. KiCad now supplies the file documentation and automated checks. A generator can focus on the design model and use the editor engineers already trust to grade its output.
The winners own the source above the drawing
Electrical teams building families of related boards gain first. A carrier board that changes connectors, power options, or processor modules across products can keep those differences in reviewable source and regenerate the repetitive drawing. Firmware teams gain when pin assignments and device addresses come from the board instead of a second spreadsheet. Mechanical engineers gain when every enclosure build starts from the board that was just saved.
KiCad also gains by becoming the editor, file format, and checker that many higher-level tools target. Its value grows even when design intent lives elsewhere. That position can prove stronger than owning a closed project file that outside software can only export at the end.
Altium and Cadence are exposed at the lower end of their markets. Their editors still carry capabilities and support that complex boards need, and neither will disappear because a small project can generate a KiCad schematic. The pressure shows up when a team can reproduce its design, run the checks on a build server, and connect the result to firmware without buying another editor seat. For boards that fit KiCad, an opaque project database becomes a cost the vendor has to defend.
The code-first vendors face pressure too. A generator that only produces an impressive first draft will lose to one that survives the hundredth ordinary edit. Stable object identity, useful diffs, and round-trip tests will matter more than how quickly a tool draws the first page.
There is a clear way this thesis could fail. If real projects produce constant merge conflicts, lose carefully arranged drawings, or require engineers to debug the generator whenever they make a manual edit, teams will return to treating the CAD file as the master. Schemy still can't reconcile every kind of KiCad change. Fusible doesn't yet compile its generated Zephyr configuration as part of the same check. Bringup labels its own measured flow a prototype. The next year needs evidence from teams maintaining products through messy, ordinary changes.
Run the regeneration test before changing tools
A hardware team can test this approach without replacing its design system. Pick one small board with firmware and an enclosure model. Regenerate the schematic or mechanical export in a clean build, run KiCad's electrical and board checks, and compare the resulting netlist with the version the team approved. Then make one normal edit in KiCad and see whether the source can absorb it without losing intent.
Tool builders should treat that round trip as the product. Show which manual edits survive, which checks prove electrical equivalence, and what happens when the generator can't understand a change. A polished drawing is weak evidence.
Our forecast is that by the end of 2027, code-defined electronics tools selling to professional teams will be expected to demonstrate round-trip compatibility on customer designs. Teams will ask whether the generated files remain editable and whether a clean build proves the same connections, long before they ask how much of the first schematic an AI can draw.