Chat and decisions
You edit a board by talking to it. Ask a question and get an answer, or ask for a change and review it before it becomes a version.
The thread is read back from the project each time you open it. So it survives restarts, and reads the same on every device.
Press Enter to send, and Shift+Enter for a new line.
Turns
Each message is a turn. What happens depends on what you ask, and on whether the project has a board yet.
| You ask | What happens | Time |
|---|---|---|
| A question: What does C1 do? | The model answers from the version on screen. Nothing is built, and no version is made. | Seconds |
| For the first board: A 555 timer LED blinker running from 5V | The model writes the whole design, and the pipeline builds it as v001 | One to three minutes |
| For a change: Add a reverse-polarity diode on the input | The model returns only what changes. The pipeline builds it as a proposal, and Accept makes it the next version. | One to three minutes |
A change names only what changes. The model lists the parts and nets it adds or replaces. A part it does not mention stays exactly as it is. A part or a net leaves the board only when the model names it for removal. So the diode is added and the regulator stays where it was.
The reply is the model's own account of what it did. The proposal's bar says what accepting it would do. It names the parts added, removed and changed, the nets that change, the ERC errors it adds or clears, and the change in price. Those come from comparing the two designs and the two builds, not from the model's description.
Select parts first to scope a change. The model may then change or remove only what you picked. See Proposals.
While a build runs, the thread shows its build log, and you cannot send another message. See Builds and live sync for what happens if you close the tab.
The chat route of the HTTP API
A script that posts to a project's chat route skips the proposal. The model returns the whole revised design, and the build is saved as a version. See the HTTP API.
Revisions
A first board that is not clean goes back to the model once before you see it. That covers a part that does not exist in its package, a pin the symbol library cannot match, or an electrical error.
- The findings go to the model, in the same words as the command line's
--repair. - The revised design is scored first: parts resolved, then electrical rules.
- It is built only if it scores better under the repair loop's rule. A deleted part scores worse than a broken one, so a revision cannot pass by dropping the failing part.
Both builds become versions, and the reply says the build was revised. A revision that scored no better is not built, and the reply says that too.
A proposal is built once and is not revised. Its bar shows what the build found, and you decide.
An unrouted net does not start a revision. The model hears about it on your next turn.
SOLDERMASK_AUTO_REPAIR sets the number of rounds. The default is 1, and 0
turns revisions off.
Which version an edit builds on
An edit builds on the version on screen. When that is an older version, the version chip says so, such as v002 of v004. Latest takes you to the newest.
Sending a message makes the version on screen current. The change becomes the
next number, such as v005, and records parent: v002. History is never
rewritten, and the newer versions stay.
Decisions
Some prompts leave a real design choice open, such as how the board is powered, or battery versus mains. The model then offers two or three options as decisions, and marks one as recommended.
- The model builds the recommended option anyway, so there is always a board on screen.
- Decisions show as cards under the reply. Clicking an option sends its label as your next message. On a board that exists, that message is built as a proposal.
- Only the newest reply's cards are live.
- A turn carries at most two decisions, and the model is told not to invent choices the prompt already settled.
The seeds
An empty project offers five prompts that build cleanly end to end:
- A 3.3V LDO breakout with input and output headers
- An I2C sensor breakout with pull-up resistors and a 4-pin header
- A 555 timer LED blinker running from 5V
- A MOSFET low-side switch driven from 3.3V logic
- A two-channel op-amp buffer with decoupling
A microcontroller board is not among them, because it starts from the @
picker on the projects page. The
picker pins the module before the model writes a word.
What the model is told
The system prompt is the one in Design (the model), plus a paragraph about the conversation. The first message on a new project is sent exactly as typed. So the app, the command line and the evaluator all ask the model the same question.
Each later turn sends, in this order:
- The history: your first message (the brief), plus the last six turns. Each message is cut at 500 characters.
- What the last build found: unresolved parts and pins, electrical errors and warnings, and unrouted nets. These use the words of the repair brief.
- The design as it stands, as JSON.
- The rules for the answer, then your message.
The paragraph about the conversation tells the model four things:
- The
replyis shown to you. - A design takes minutes to rebuild, so it changes the board only when the board should change.
- A returned design is complete, with every surviving reference kept. This holds for a first board and the chat route.
- It should fix what the last build found, unless you say otherwise.
For a change to an existing board in the workbench, the rules ask for an edit instead:
| Rule | What it means |
|---|---|
| Return only what changes | A reference already on the board replaces that part. A new one adds a part. |
| A net listed is the whole net | The model gives every connection of a net it lists, not only the new ones |
| Remove by name | A part or a net leaves only when named for removal. Deleting a part to clear an error is ruled out. |
| A question builds nothing | A question or a remark is answered in reply, with no edit |
| Stay in scope | With parts selected, the model may add anything, but change or remove only what you picked |
The answer's schema has no field for the whole design. So a part the model never mentions cannot be lost.
When there is no model
If no model backend is set up, the thread says why, and you cannot send. For
example: Claude Code is not logged in. Run claude once and log in with your claude.ai account, or set SOLDERMASK_BACKEND=gemini.
While the model works, each part it looks up and each check it runs shows as a line in the build log.
You can still build from a design.json. Use Open a file on the
projects page.