---
title: "Workshop projects and the Maker Pack — Robion user manual"
description: "Maker projects: the Maker Pack, the six workshops, the design panel and its gates, renders, drawings, BOM, the live customizer."
url: "https://robion.app/docs/workshop/"
lang: en
---

# Workshop projects and the Maker Pack

Making a physical thing in Robion: the Maker Pack plugin, the six workshop cards on the home
screen, the workshop project type and its design panel, where the outputs show up, and what the
optional tools (OpenSCAD, kicad-cli, build123d) add.

## The Maker Pack

- "skills for physical products (parametric CAD, drawings, BOM); a Claude Code plugin installed
  from github.com/biokys/robion-maker-pack" — the plugin is called `maker`. It holds the process:
  the agent turns your idea into a brief, keeps a design record, models in parametric code,
  produces renders, drawings, materials, a build plan, checks and a build sheet.
- ⚙ → **Agents** → **Maker Pack**: the state (**installed**, **update available**, **not
  installed**, "plugin registry cannot be read") and the buttons **install**, **update**,
  **remove**. Install and update run `claude plugin …`; they change content only — "agents pick
  it up in their next session". "a personal skill of the same name runs alongside the pack:"
  warns about a skill in `~/.claude/skills` shadowing the pack.
- When the installed pack is behind, a banner "Maker Pack has an update (x → y)" with **update**
  sits above the workspace. The home screen adds "physical verticals run on the Maker Pack —
  install it in settings" while the pack is not installed.
- Pack versions the panel needs: the design record from pack 0.23, the brief panel pages from
  0.24, the gates inside the design panel from 0.26 (older packs keep the plain brief panel).

## Six workshops on the home screen

- The project's home surface shows **six workshops · one process** — "click an example — a task
  starts working on it right away": the click creates a Claude Code task titled after the
  example with the example's prompt. A project must be selected ("pick a project in the left
  column").
- **3D print** ("from prompt to STL today; slicing and print monitoring next"): Raspberry Pi
  case, handlebar phone mount, drawer organizer, replacement part, headphone stand.
- **electronics** ("KiCad boards with DRC/ERC, gerbers, board-in-enclosure fit"): ESP32 relay
  board, battery sensor, board-in-enclosure fit, schematic review, USB-C power module.
- **wood** ("furniture-grade drawings, BOMs and finishing plans; cut plans next"): coffee table,
  wall shelf, van conversion, chicken coop, plyo box.
- **metal** ("welded & bolted frames from steel profiles; sheet-metal flat patterns"): welded
  gate, workshop rack, sheet-metal box, wall pull-up bar, aquarium stand.
- **CNC & laser** ("DXF and true-scale PDF today; toolpaths and nesting next"): laser-cut grille,
  tab & slot box, routed sign, drilling jig, canvas bag pattern.
- **software** ("where Robion started: agents, worktrees, diffs, reviews"): architecture map,
  fix a flaky test, code review, dependency audit, fill in tests.

## The workshop project type

- New project (⊕ in the rail, File → **New Project…**) asks **What kind of project?**:
  **Development** ("software: terminal, files, git") or **Workshop** ("I want to make a thing:
  the design panel leads, the agent works in the background"). Switch later in ⚙ → project →
  **Project type**: "workshop = the design panel is the anchor and the agent runs without a
  terminal tab; development = terminals, tree and git as usual".
- In a workshop project the design panel is the anchor tab (no close button; a layout reset keeps
  it), a new task opens no terminal tab, and the running agents show as **agent** chips in the
  top bar with their state dot — "the task is running but its terminal is closed — click reopens
  it". The side panel starts folded (⌘B). Starting a task never
  asks about tasks awaiting review here.
- ⚙ → **Application** → **Agent in workshop projects**: "Claude Code of a Workshop-mode
  project gets its own settings for that session only (--settings): a lower effort and the
  default output style (no Insight blocks), optionally another model; an empty field keeps your
  own setting (1M context included); your saved defaults are never changed". Effort low /
  medium / high or **effort: yours**; the model field placeholder is **your model**. Robion
  never compacts a session on its own (since 0.15.1 it no longer types /effort either).

## The design panel: starting a design

- Its first screen asks **What do you want to make?** — "Describe the product: what it is for,
  who uses it, the dimensions you know, what it must survive. The agent turns it into a brief
  and asks about what is missing." Then **start the design**, or **or try an example** (the six
  cards' prompts).
- **add a photo**: "photos for inspiration or as reference: pick files, drop them from the Finder
  or paste from the clipboard (⌘V)" — JPEG or PNG, "at most 6 photos per message"; they land in
  the project's `.robion/uploads` and the agent looks at them before the brief; the record shows
  them under the idea. The composer at the bottom takes photos with every later note too.
- Then: "the agent is reading your brief and writing the design record — the questions appear
  here in a moment". Before the record exists the panel says "No design record yet. It appears
  here as soon as the agent writes design.json after the brief analysis (Maker Pack)".

## The design record (design.json)

- `design.json` lives in the task's working directory and holds the **idea**, the **spec**, the
  **answers** with who decided them (**you** / **default** / **Claude decided**), the
  **concept** and the **changes** log, plus the map of ten stages: **Idea**, **Brief**,
  **Concept**, **Model**, **Previews**, **Drawings**, **Materials**, **Build plan**, **Checks**,
  **Build sheet**, each **not started**, **working**, **needs you**, **done**, **out of date** or
  **skipped**; "every stage done" at the end.
- Only the pack's `design_record.py` writes it (real timestamps, validation, a commit at every
  gate); Robion never does. The record column on the right is resizable; **design.json** opens
  the file. A broken record says "the design record is damaged — the agent can repair it" with
  **ask the agent to repair it**.
- The panel follows the current stage by itself; a click pins another one, **back to the current
  step** returns.

## Gates: answering in the panel instead of the terminal

- The question round is a form with the recommended answers in place and **decide for me** per
  question; **send the answers** records them ("several answers are fine", **own answer**).
- The concept step shows variants as cards with a **recommended** badge and **enlarge the
  picture**; **choose this variant** picks one ("pick one in the concept step" elsewhere).
- A produced step is an approval screen with the renders, tables and files and one **continue**
  button ("next: <stage> · estimate …"; on the last step "the last step — approving finishes the
  design"). Want it different? "Want something changed? Write it below — the step goes back to
  the agent with your note."
- The agent's own questions (AskUserQuestion) show as **the agent asks** cards and are answered
  here; a permission shows "the agent asks for a permission — answer here, in the terminal or on
  the phone".
- Your reply is written into the record through the project's own script and the agent is told
  in one line ("reply recorded"); the map moves when the record moves, never before ("sent to
  the agent; the record has not caught up yet"). The phone has the same gates in its design tab.
- Changing an earlier answer: **change** on a recorded answer — "the agent updates the record and
  says what goes out of date"; stages it invalidates turn **out of date** and regenerate; **undo**
  reverts a pending change.

## Watching the agent work

- The live line: "sent to the agent…", "the agent is working" with a clock, "the agent is waiting
  for you", "the agent is not running", "the agent hit an error — see the terminal", or "the step
  says working, but the agent stands still — nudge it below or look at the terminal"; beside it
  the model and its context window ("context window of 1.0M tokens") and the estimate.
- "what the agent is doing": phase, its step list, last reply, tool calls, allow/deny for a
  permission. **stop** interrupts it ("Esc — what it wrote so far stays, the next message
  continues"); **terminal** / **show the terminal** opens the pane; **questions** opens the brief
  panel as a tab of its own.
- The step body says "waits for “<stage>”", "done — the files of this step", "out of date — the
  agent regenerates this step after the change" or "the agent has put nothing on this step yet".
- The composer: "A note or a change for the agent…" plus photos, **send**; "the agent is waiting
  on a dialog or is not running" blocks it.

## What a design costs

- The header shows **so far ~<amount>**, each step **step ~<amount>** (also in the step's files
  line). With **Claude subscription** set in ⚙ → **Application** ("what you pay per month") the
  amount is the design's share of the month's tokens × the price ("<share> of this month's
  tokens × the <price> subscription"); without it, "estimate at API prices as Claude Code
  reports it".

## Outputs and where they appear

- By stage: the model as parametric code (build123d Python or OpenSCAD) and STEP/STL, previews
  (renders), drawings (PDF, DXF), materials (BOM), a build plan, checks (strength/FEA images,
  KiCad DRC/ERC), a build sheet. By workshop: 3D print ends at STL and a print plan for your own
  slicer — Robion never slices; electronics gives a KiCad schematic, layout, DRC/ERC and gerbers;
  CNC & laser give DXF and true-scale PDF.
- Where: a done step lists its files in the step body (a click opens them); the agent opens
  results in panels — models in the 3D panel, renders, drawings, DXF and Gerber in the media
  panel, BOM and plans as markdown — or puts them into a controls panel as image tiles, galleries
  and tables. `.robion/` in the project is git-excluded scratch (uploads, quick renders); the
  rest sits in the tree (⌘B).

## The live customizer

- For a parametric model the agent builds a controls panel (a tab named after the part) with
  sliders marked as parameters and the model as its viewport: moving a slider re-renders the 3D
  view — no render button (OpenSCAD gets `-D key=value`, a Python model reads `ROBION_PARAMS`).
  A render or export button beside it runs with the current values, often silent (it pulses
  while it runs) with image tiles that refresh when the files are rewritten.
- 3D panel details for makers — the **⌸ bed** print-bed outline with "the model fits" / "the
  model does not fit", the **Δ original** ghost of the version before the last agent turn, the
  volume in the readout — are in [panels.md](https://robion.app/docs/panels/).

## Tools, print bed and limits

- ⚙ → **Tools**: **OpenSCAD**, **kicad-cli**, **Python with build123d** ("empty = nearest
  .venv/bin/python above the file, otherwise python3"); "Empty path = automatic detection (PATH,
  /Applications)"; **Detected tools** shows "version and path as the server sees them" or "not
  found". **Print bed**: "width × depth in mm; the 3D panel can draw it under the model and
  reports when the model does not fit; empty = off". **3D render timeout**: "a render (OpenSCAD,
  build123d, kicad-cli) is killed after this time".
- Without OpenSCAD `.scad` files do not render ("OpenSCAD not found. Install it or set … in
  config.json" in the 3D panel); without kicad-cli there is no board render and no DRC/ERC;
  without a Python that has build123d a `.py` model fails with the hint to set
  `build123dPython`. Images, PDF, DXF, SVG and Gerber files need no external tool.
- The desktop app runs on macOS; the server can also run headless on a Linux box paired in
  ⚙ → **Servers** (photos in the design panel need the server on 0.15 or newer).
