Skip to content
Back to search

assembly-guide

SkillWorks with Claude CodeGitHub

Open a STEP assembly and get an animated, editable build guide with a printable instruction sheet and a shareable read-only page. Runs in the browser, nothing is uploaded. Includes Claude skills for Fusion 360.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/averagearc--assembly-guide/badge.svg)](/listings/averagearc--assembly-guide)

HTML

<a href="/listings/averagearc--assembly-guide"><img src="/api/listings/averagearc--assembly-guide/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 119 lines
  1. # Assembly guide
  2. Open a CAD assembly and get an animated build guide you can edit, a printable instruction sheet, and a read-only page you can share.
  3. A STEP file says what the parts are and where they sit. It does not say what order to build them in. This project gives you two ways to supply that order, and both end in the same guide.
  4. ## Two ways to make a guide
  5. | | **By hand** | **By agent** |
  6. |---|---|---|
  7. | Who works out the build order | You | An LLM agent, from its own judgment of the parts and how they fit |
  8. | Input | A `.step` / `.stp` file you open in the browser | Either a **STEP file** (the site gives the agent a model summary to read) or the **assembly open in Fusion 360** (read through its MCP tools) |
  9. | Where it lives | `site/` (static site, runs in your tab) | `site/` (model summary) and `skills/` (Claude skills for Fusion) |
  10. | What you do | Drag in the file, read the draft, then reorder, rename and write the steps yourself | Give the agent the model summary (or ask it for a guide in Fusion), answer the few questions only you can answer, then review |
  11. | What you get | The guide page, a printable sheet, a public page to share | The same |
  12. ### 1. By hand: import a STEP file and build the steps yourself
  13. Drop a STEP file into the site. It reads the file in your browser (nothing is uploaded), sorts the parts, and drafts a starting order. From there the guide is yours to shape:
  14. - start from a draft that runs **back to front** (or choose front to back, bottom up, top down, middle out, outside in, or by contact), and re-arrange all the steps in any of those directions later with **Arrange all steps**, with an undo; fasteners always stay after the parts they fasten
  15. - reorder, add, delete and merge steps, with **undo, redo** and a button that goes back to the first draft
  16. - write titles, instructions and tools for each step
  17. - rename parts, move a part to another step, change what a part counts as (hardware or structural), and change the side it arrives from, including **the angle you are looking from in the 3D view**
  18. - cut a step open with a **section view** (front, right or top) to show where a part goes when it sits inside another: the model is sectioned through the middle of the part being added, which stays whole, and the cut slides in, moves between planes and slides out as the steps play. Cut faces are solid and drawn the way a drawing sheet does it: white, hatched at alternating angles, with a bold outline
  19. - end with a **finished view**: a last page showing the whole assembly (from the angle you choose) with a title and a note, which also becomes the last section of the printed sheet
  20. - save the 3D view you like as a step's **camera**. The printed sheet's pictures are the same views the playback uses: one picture per step, drawn from the step's saved camera if it has one, otherwise from its section view, otherwise from the side its parts arrive from. Each shows only what is built so far, with the new parts highlighted, and the sheet opens with a complete picture and ends with the finished view
  21. - play it back with parts flying into place, then print the instruction sheet or download a read-only public page
  22. ### 2. By agent: let an LLM propose the steps
  23. The agent route is for when you want an LLM to do the thinking about build order. Scripts export the model and work out what touches what and which side each part can arrive from. The agent then reads that, decides the order a person would actually build it in, groups parts into sub-assemblies, and writes real step titles and instructions. It asks you only what the model cannot tell it: where to start, which sub-assemblies to build first, what tools you have.
  24. There are two ways to hand an assembly to an agent:
  25. - **From a STEP file, with any LLM.** Open the file on the site and choose **Model summary for an assistant**. You get a small JSON file (no triangles, a few KB for a small motor, tens of KB for a model of a few dozen parts) that lists every part with its name, kind, size, position, what it touches and which side it arrives from, and that explains the task to whoever reads it. Give it to any assistant or agent, or choose **Copy as prompt** to copy the summary with a ready-made request and paste it straight into a chat. It answers with a steps file, and you load that with **Open steps**, which tells you how many steps loaded, how many parts landed in a step, and what was renamed, ignored or left out. Each part comes with a computed description ("flat plate, 90 mm long", "at the back, near the top"), and repeated parts (14 identical washers) are described once in a group. The guide for agents is [`docs/agent-guide.md`](docs/agent-guide.md).
  26. - **From Fusion 360, with Claude.** Two skills read the assembly open in Fusion, with real materials, masses and hidden state:
  27. - `fusion-assembly-guide` builds the guide.
  28. - `fusion-parts-editor` cleans up part names, materials and colors first, so the agent has good names to work from.
  29. The result is an ordinary guide with an edit mode, so an agent's first pass is a starting point you can correct by hand.
  30. **Open format.** A guide's steps are a small JSON file (`fusion-assembly-steps/1`, documented in [`skills/fusion-assembly-guide/references/steps-format.md`](skills/fusion-assembly-guide/references/steps-format.md)). Any agent can write one, and the guide page loads it. The same file travels both ways: steps you wrote by hand can be handed to an agent to refine, and steps an agent wrote can be opened and edited in the site.
  31. **Where this stands.** Both agent routes work, but the STEP route is new and has been checked end to end only with a stand-in answer (a script playing the agent), not yet with a real assistant on a real model. The Fusion route has been used on assemblies of several dozen to a few hundred parts.
  32. ### What both routes share
  33. - The same guide page: playback, explode view, parts list, printable sheet, and a read-only public mode with no editing tools. What you see in "Preview public view" is what viewers get.
  34. - The same analysis (`site/analysis.mjs`), which classifies parts, finds contacts, picks arrival sides and drafts an order.
  35. - The same rule: **the order is a draft.** Whether you or an agent wrote it, it is a starting point and the guide is built to be edited.
  36. ## Run the site
  37. ```bash
  38. node serve.mjs 8800
  39. ```
  40. Then open http://localhost:8800 in Chrome or Edge and drop in `examples/nema17-pancake-stepper-motor.step`. (Do not double-click `index.html`: the STEP reader cannot start from a `file://` address.)
  41. ## Use the Fusion skills
  42. Copy `skills/*` to `~/.claude/skills/` (or run `node tools/sync.mjs --install`), open an assembly in Fusion 360 with the Fusion MCP connected, and ask Claude to tidy the parts or make an assembly guide. Each skill's `SKILL.md` has the steps.
  43. ## Where the files go
  44. For the Fusion route, everything for one assembly goes in its own folder under `output/` (ignored by git, because it holds your geometry), named after the Fusion document:
  45. ```
  46. output/<project-name>/
  47. assembly-edit.html the page you edit
  48. assembly-public.html the read-only page to share
  49. steps.json your steps (keep this; it rebuilds either page)
  50. work/ the export, analysis and draft steps (can be deleted)
  51. ```
  52. For example `output/front-bearing-stack-injection/assembly-edit.html`. On the standalone site, the browser saves downloads (the steps, the public page) to your Downloads folder, and that is the one place the tool cannot choose.
  53. ## Name your parts before you export
  54. The guide is only as clear as the part names in your file. A STEP file carries whatever names your CAD program had, and the tool, and any AI agent reading it, can only go by those names, sizes and positions.
  55. - **Good names say what the part is:** "Back plate", "Rear clamp block", "M3x8 Torx screw", "Pen collar". The tool uses names to tell screws, nuts and washers from other parts, and an agent uses them to decide what goes where.
  56. - **Generic names cause guesses:** "Body12", "Component7" and "COMPOUND 3" give nothing to go on. An agent has to guess a part's purpose from its shape, and it can be wrong.
  57. - **Name the solids, not only the folders.** If several solids sit in one unnamed group, they come out as "COMPOUND 1", "COMPOUND 2" and so on. Give each body or component its own name in your CAD program before you export.
  58. - **The site tells you.** After loading, if three or more parts (and at least a tenth of them) have placeholder names, a notice says so.
  59. - **Fix it later if you have to.** You can rename any part in the guide (click it), and an agent can propose better names, but only inside the guide. Your CAD file stays as it was. Check an agent's renames, because they are guesses.
  60. - **Spacers and standoffs can be hardware or structural.** A molded spacer block is a part of the build; a threaded standoff goes in with the screws. The tool reads cues in the name (block, frame, molded, M3, hex, nylon) and falls back on size, and tells you which it had to guess. Click a part and set **Counts as** to correct it.
  61. - **The full naming guide** is [`docs/naming-guide.md`](docs/naming-guide.md): which words the tool reads, how it tells hardware from structural parts, and a check list before you export.
  62. - **Fusion 360 users:** the `fusion-parts-editor` skill renames parts and fixes materials in the open assembly first, so the guide starts from good names.
  63. ## What a STEP file cannot tell us
  64. Build order, materials, masses, which parts are hidden, and which way is up are not in a STEP file. The site says so in its interface. The Fusion route can read materials, masses and hidden state from Fusion directly.
  65. ## Layout
  66. | Folder or file | What it is |
  67. |---|---|
  68. | `site/` | The deployable static site: page, worker, converter, analysis, page builder, guide template, vendored libraries. |
  69. | `serve.mjs` | Tiny local server for `site/`. |
  70. | `output/` | Pages and files the tools make for your assemblies, one folder per project (not in git). |
  71. | `docs/naming-guide.md` | How to name parts so the tool and any assistant read them right (hardware or structural, size in the name). |
  72. | `docs/agent-guide.md` | How an agent writes the steps for an assembly (the model summary in, a steps file out). |
  73. | `skills/` | The two Claude skills (copies; install with `node tools/sync.mjs --install`). |
  74. | `tools/sync.mjs` | Keeps the shared files in `site/` and the skill in step. |
  75. | `examples/` | The sample: a NEMA 17 pancake stepper motor as a STEP file, its steps file, and the finished public guide page. |
  76. | `NOTES.md` | What exists, decisions, lessons, what is tested, next steps. |
  77. | `CLAUDE.md` | Project rules for Claude sessions. |
  78. ## Status
  79. Both routes work and have been tried on a sample STEP file (the NEMA 17 motor in `examples/`) and on real Fusion assemblies. Parts are drawn from the STEP file's exact surfaces at fine detail, never as boxes. Recent additions: better drafting (sub-assembly steps, merged repeats, middle-out ordering), hardware or structural spacer detection, undo and redo, section views with hatching, and a finished view. Section views and the finished view have not been checked on the public page or in a real print. See **`NOTES.md`** for what was done, what is tested and what comes next.
  80. ## Licenses
  81. This project is released under the [Apache License 2.0](LICENSE) (copyright 2026 AverageArc). If you fork or redistribute it, keep the [`NOTICE`](NOTICE) file, which credits the original project.
  82. OpenCascade (via occt-import-js) is LGPL-2.1 and three.js is MIT; those files keep their own licenses, and the notices are in `site/vendor/`.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.