Skip to content
Back to search

factory

SkillWorks with Claude CodeGitHub

Turn a one line description of a factory ("a line that makes 2,000 e-bike motors a day", "a bakery that bakes 10,000 croissants an hour", "a battery cell gigafactory") into a single self-contained HTML page with a live 3D tilt-shift miniature of that factory, driven by a real discrete event simulation (stations, cycle times, batches, finite buffers, shifts, breakdowns, scrap) with a live HUD for throughput against target, takt, utilization, WIP, lead time and the bottleneck, where clicking a station lets you add a machine or change a cycle time and watch the bottleneck move. Use it whenever someone wants to see, size, explain or pitch a production line, plant, assembly line, process or factory, asks "how many machines do I need", "where is the bottleneck", "can this line make N a day", wants a factory simulation or digital twin demo, or describes a product and a volume, even if they never say "simulation".

Safety scan

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

Checked yesterday
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/airsuphq--factory-skill/badge.svg)](/listings/airsuphq--factory-skill)

HTML

<a href="/listings/airsuphq--factory-skill"><img src="/api/listings/airsuphq--factory-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add AirsupHQ/factory-skill -g -a claude-code

Then, in Claude Code:

/factory a line that makes 2,000 e-bike motors a day

No API keys and nothing to `npm install`: the scripts use only Node built-ins and the page is one self-contained HTML file.

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.

SKILL.md · Manifest · 208 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: factory
  3. description: Turn a one line description of a factory ("a line that makes 2,000 e-bike motors a day", "a bakery that bakes 10,000 croissants an hour", "a battery cell gigafactory") into a single self-contained HTML page with a live 3D tilt-shift miniature of that factory, driven by a real discrete event simulation (stations, cycle times, batches, finite buffers, shifts, breakdowns, scrap) with a live HUD for throughput against target, takt, utilization, WIP, lead time and the bottleneck, where clicking a station lets you add a machine or change a cycle time and watch the bottleneck move. Use it whenever someone wants to see, size, explain or pitch a production line, plant, assembly line, process or factory, asks "how many machines do I need", "where is the bottleneck", "can this line make N a day", wants a factory simulation or digital twin demo, or describes a product and a volume, even if they never say "simulation".
  4. ---
  5. # Factory
  6. **Describe a factory in one line. Claude builds it as a live 3D simulation you can run.**
  7. The page is a model factory on a table, seen through a tilt-shift lens: a cut-away hall with
  8. the line inside, machines that move while they work, product flowing on conveyors, people, forklifts, a
  9. truck yard. Under it runs a discrete event simulation. Every number on screen comes from that
  10. simulation, never from a script: the throughput, the utilization bars, the WIP, the pulsing red
  11. outline around the bottleneck. When someone adds a machine at the bottleneck, the simulation gets
  12. one more server, the conveyor in front of it drains, and the outline moves to the next constraint.
  13. ## The one rule that matters
  14. **The simulation is the explanation, so it has to be true.**
  15. - Cycle times, batch sizes, dwell times, breakdown rates and yields come from how the real process
  16. works. Use the numbers a process engineer would recognise and say in `note` where they come from
  17. ("18 min at 180 C", "51 slots, 3 needle head"). When you have to estimate, say "typical".
  18. - Machine counts come from the sizing rule, which the page prints in the inspector:
  19. `machines = CEIL(rate_in x cycle / (batch x availability x target utilization))`.
  20. - Throughput, utilization and the bottleneck come out of the simulation. Never tune inputs to make
  21. a nicer result. If the first line misses its target, that is the finding: report it, show it, and
  22. let the user fix it with the slider.
  23. ## Workflow
  24. Run `date` at the start. A factory takes 10 to 25 minutes.
  25. 1. **Read the line.** Pull out the product, the volume and the time unit. Fill in what is missing with
  26. stated assumptions: shifts (2 x 8 h unless the process runs around the clock, like cells,
  27. chemicals or glass), the product variant ("250 W rear hub motor"), the scope ("the canning hall,
  28. from bright tanks to pallets"). Say them in one short paragraph before building.
  29. 2. **Route.** Write the real process route as 6 to 10 stations, in flow order, with branches where
  30. sub-assemblies are made in parallel and joined (stator + rotor + housing into motor assembly).
  31. Each station: what happens, the machine that does it, the cycle time per unit or per batch, the
  32. batch, MTBF/MTTR if it is a machine that breaks, yield if it is a test or inspection.
  33. `references/process.md` has typical numbers for common processes and how to pick them.
  34. 3. **Pick the token.** One token is one unit unless the line is fast. Choose `perToken` so one token
  35. leaves the line every 5 s to 2 h (a tray of 40 croissants, a case of 24 cans, a tray of 96 cells).
  36. 4. **Write `spec.js`** (schema below). Start from the closest example in `examples/`.
  37. 5. **Check it headless.** `node scripts/check.mjs spec.js`. It sizes the line and runs 5 production
  38. days of the same engine the page runs, and prints per station: machines, capacity per day, busy,
  39. down, blocked, starved, failures; then the forecast and the bottleneck. Read it like an engineer:
  40. - Does each machine count look like a real plant? 446 proofer slots is right (4 chambers of 120);
  41. 40 laminators is a wrong cycle time.
  42. - Is the bottleneck plausible? Long dwell steps and machines with poor availability usually are.
  43. - Fix mistakes in the inputs (a wrong unit, a batch you forgot). Do not fix the result.
  44. 6. **Build.** `node scripts/build.mjs spec.js <out>.html` writes one file of about 1 MB with three.js,
  45. the runtime and the spec inlined. It opens from disk with no server and no network.
  46. 7. **Look at it.** `node scripts/capture.mjs <out>.html shot.png --query "assemble=0"` (needs
  47. Playwright) and read the PNG. The line should fill the frame, every station should have its
  48. machines, product should be on the conveyors, the HUD should show a throughput. Zero console errors.
  49. 8. **Answer** with the file path, the forecast against the target, the bottleneck and why, the sizing
  50. of the bottleneck station, and one what-if to try ("add a third winder: the forecast goes from
  51. 1,943 to 2,0xx a day and the constraint moves to EOL test"). Run that what-if through
  52. `check.mjs` (edit `servers` on a copy) before you quote it.
  53. ## Spec
  54. ```js
  55. FactorySkill.define({
  56. id: 'ebike-motors', // file name
  57. prompt: 'a line that makes 2,000 e-bike motors a day', // the user's line, typed into the page
  58. title: 'E-bike hub motor line',
  59. product: { name: 'motor', unit: 'motors', perToken: 1 },
  60. demand: { perDay: 2000 }, // or perHour, or perWeek (5 days)
  61. calendar: { shifts: 2, hoursPerShift: 8, startHour: 6 },
  62. sizing: { targetUtil: 0.85 }, // planned utilization for the sizing rule
  63. release: 'capacity', // 'capacity': raw material always there (find the max), 'takt': released at demand
  64. seed: 11,
  65. stations: [
  66. { id: 'stamp', name: 'Lamination press', machine: 'press', ct: 22, cv: 0.04, buffer: 8,
  67. mtbf: 6 * 3600, mttr: 25 * 60, input: 'coil', stage: 'stack', note: '64 laminations at 180 strokes/min' },
  68. { id: 'wind', name: 'Needle winding', machine: 'winder', ct: 150, after: ['stamp'], stage: 'wound' },
  69. ...
  70. ],
  71. stages: { coil: { shape: 'coil', color: '#8d949b' }, stack: { shape: 'ring', color: '#6f7780' }, ... },
  72. })
  73. ```
  74. Station fields:
  75. | field | meaning |
  76. |---|---|
  77. | `id`, `name` | key and the name on the plate and in the HUD |
  78. | `machine` | a kit machine (table below) or an alias such as `lathe`, `proofer`, `pasteurizer`, `seamer` |
  79. | `ct` | seconds per cycle per machine; with `batch` it is the time for the whole batch |
  80. | `cv` | coefficient of variation of the cycle (lognormal). Automatic 0.02 to 0.06, manual 0.1 to 0.2 |
  81. | `batch` | units taken and released together (a chamber oven, a mixer, a TVAC) |
  82. | `perMachine` | units one physical machine holds at once in continuous flow (tunnel oven, spiral, proofer, formation rack). The DES gets that many servers per machine with `ct` = dwell time |
  83. | `servers` | `'auto'` (default, sizing rule) or a number of machines (times `perMachine`) |
  84. | `buffer` | capacity of the input buffer (each input of a join has its own) |
  85. | `mtbf`, `mttr` | mean busy seconds between failures and mean repair seconds (exponential) |
  86. | `yield` | fraction good; the rest is scrapped at this station |
  87. | `after` | predecessor ids. Default: the previous station. A station with `input` starts a new branch |
  88. | `input` | the raw material stage a branch starts from |
  89. | `stage` | the product stage this station outputs (looks up `stages`) |
  90. | `note` | where the numbers come from, shown in the inspector |
  91. | `variant`, `color`, `accent`, `length`, `radius`, `height`, `fill`, `web`, `glow` | looks |
  92. | `operators`, `reserve`, `at: [col, row, dir]` | people beside machines, spare floor slots, manual grid placement |
  93. The model is a tree into one last station (the sink): every station feeds exactly one next station.
  94. ## Kit
  95. Machines (real scale, metres) in `runtime/kit.js`:
  96. | machine | looks like | kind |
  97. |---|---|---|
  98. | `cnc` | machining centre, window, moving spindle, chip conveyor | side |
  99. | `press` | press with ram and flywheel, coil feeder; `variant: 'magnetizer'` | side |
  100. | `winder` | needle winder, spinning table, wire spools | side |
  101. | `robot` | fenced 6 axis arm cell; `variant: 'weld'` adds arc and sparks | side |
  102. | `bench` | assembly bench with an operator, bins, tool balancer | side |
  103. | `tester` | test rack with screens and a clamp fixture | side |
  104. | `oven` | chamber oven with racks (batch); `variant: 'proofer'` | side |
  105. | `mixer` | spiral or planetary mixer with turning bowl | side |
  106. | `filler` | rotary filler / seamer in a glass enclosure | side |
  107. | `formation` | racks with blinking channels (formation, ageing, burn-in) | side |
  108. | `tank` | stainless tank with agitator, ladder, piping | side |
  109. | `laser` | laser cell with glowing window | side |
  110. | `turntable` | calibration turntable with camera tripods | side |
  111. | `cage` | flight / function test cage; the unit lifts while tested | side |
  112. | `bay` | integration bay with gantry crane and technicians; `variant: 'cleanroom'` | side |
  113. | `chamber` | thermal vacuum / autoclave vessel with a round door (batch) | side |
  114. | `kitting` | shelving with bins and a picker | side |
  115. | `stacker` | high speed stacking / winding head | side |
  116. | `cell` | generic enclosed process cell (anything else) | side |
  117. | `tunnel` | tunnel oven, dryer; `variant: 'pasteurizer' | 'washer'` | inline |
  118. | `spiral` | spiral cooler / freezer / proofer tower | inline |
  119. | `rollers` | sheeter, laminator, `variant: 'calender' | 'slitter'` | inline |
  120. | `coater` | roll to roll coater with drying oven | inline |
  121. | `smt` | printer + pick and place + reflow | inline |
  122. | `vision` | inspection arch over a belt | inline |
  123. | `packer` | case packer / flow wrapper | inline |
  124. Product shapes for `stages`: `ring wound rotor hub disc coil box crate tote croissant tray dough sheet
  125. can sixpack bottle cell pouch roll module pack pcb frame drone satellite bus sneaker bag puck`.
  126. Each takes `color` and `scale`; `tray` takes `item: 'croissant' | 'dough'`.
  127. A process with no fitting machine: use `cell` with a `glow` colour, or define one in the spec file
  128. before `define` (guarded, so `check.mjs` can run the file without a browser):
  129. ```js
  130. if (FactorySkill.Kit) FactorySkill.Kit.def('kiln', (o) => {
  131. const K = FactorySkill.Kit, { g, M, body, acc } = K.sideBase(o, 3, 2.4)
  132. K.box(g, 3, 2.2, 2.2, body, 0, 0, 0) // K.box(parent, w, h, d, material, x, yBottom, z)
  133. const door = K.live(K.group(g, 0, 0, -1.1)) // parts that move live in K.live groups
  134. K.box(door, 1.4, 1.6, 0.08, acc, 0, 0.3, 0)
  135. return K.finish({ g, kind: 'side', w: 3, d: 2.4, h: 2.4, entry: K.V(0, 0.9, -1.3),
  136. work: K.workFixed(0, 0.9, 0), anim(s) { door.position.y = s.state === 'busy' ? 0 : 1.4 } }, o, [1.2, 2.2, -0.9])
  137. })
  138. ```
  139. `references/kit.md` has the whole API (materials, parts, people, vehicles, `work(i, p)` for units that
  140. move through a machine).
  141. ## The page
  142. - Opens on the assembled factory, already 3 production hours in (more for slow lines) so buffers hold
  143. WIP. `?intro=1` types the prompt and assembles the factory station by station first.
  144. - HUD: throughput per day over the last 4 h against the target, a sparkline per production hour,
  145. takt, WIP, lead time, the bottleneck card, one bar per station split into busy, blocked, starved and
  146. down. The bottleneck station gets a pulsing red outline on the floor; nothing else is labelled.
  147. - Click a station (or its row) for the inspector: machines with minus and plus (spare floor is
  148. reserved), cycle time and buffer sliders, the sizing formula with its numbers, MTBF/MTTR, failures,
  149. scrap, and a 3 day forecast of the changed line from the same engine.
  150. - Speed buttons scale production time; the clock shows day, time and shift.
  151. - `?film=1` stops the clock: `window.__film.step(dt)` renders one frame. `window.factory` exposes
  152. `select(id)`, `setMachines(id, n)`, `setCT(id, s)`, `setBuffer(id, n)`, `camTo({az, el, dist, target}, s)`,
  153. `stationCenter(id)`, `forecast()`, `sim`, `world`.
  154. - Other URL options: `speed`, `seed`, `release=takt`, `select=<id>`, `ui=0`, `assemble=0`, `ao=0`.
  155. ## Look
  156. Tilt-shift miniature photography, not a CAD view: warm sun with soft shadows, ambient occlusion, a
  157. narrow band of focus with heavy blur above and below, saturated warm grade, vignette, grain. The
  158. factory sits on a diorama base on a table: cut-away hall (back and left walls full height, front and
  159. right cut low with the section face coloured), racking along the back wall, clutter on free floor,
  160. truck yard, parking, trees, a sign. Machines are cream with one accent colour per station.
  161. `references/look.md` explains each choice and what to keep when you extend it.
  162. ## Verify like a critic
  163. - `check.mjs` numbers match the HUD after a few hours (the HUD window is 4 h, so it is noisier).
  164. - Every station shows its machines; nothing floats; tokens sit on belts or in machines.
  165. - At the bottleneck the input buffer is full and machines upstream show amber (blocked); downstream
  166. rows show grey (starved). If not, the bottleneck is downtime driven: say so.
  167. - Add a machine at the bottleneck in the page: the forecast line updates and the outline moves within
  168. about an hour of production time.
  169. ## Files
  170. | path | what |
  171. |---|---|
  172. | `runtime/des.js` | the simulation engine and the sizing rule (pure, runs in Node and the browser) |
  173. | `runtime/kit.js` | machines, products, people, vehicles |
  174. | `runtime/world.js` | layout, hall, conveyors, token placement from simulation state |
  175. | `runtime/look.js` | renderer, light, AO, bloom, tilt-shift, grade |
  176. | `runtime/app.js`, `runtime/hud.css` | page, HUD, inspector, film hooks |
  177. | `vendor/three.bundle.js` | three.js r185 and the addons used (MIT) |
  178. | `scripts/check.mjs`, `scripts/build.mjs`, `scripts/capture.mjs` | headless run, build, screenshot |
  179. | `examples/*/spec.js` | six factories made with this skill, each with its built page |
README.md · README · 166 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">Factory</h1>
  2. <p align="center"><b>Describe a factory in one line. Claude builds it as a live 3D simulation you can run.</b><br>An open source agent skill: a tilt-shift miniature of your factory, driven by a real discrete event simulation.</p>
  3. <p align="center">
  4. <a href="https://code.claude.com/docs/en/skills"><img src="https://img.shields.io/badge/Claude_Code-skill-24262a?style=flat-square" alt="Claude Code skill"></a>
  5. <a href="https://agentskills.io"><img src="https://img.shields.io/badge/Agent_Skills-compatible-24262a?style=flat-square" alt="Agent Skills compatible"></a>
  6. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-24262a?style=flat-square" alt="MIT license"></a>
  7. <a href="#requirements"><img src="https://img.shields.io/badge/dependencies-0-24262a?style=flat-square" alt="No dependencies"></a>
  8. <a href="https://www.airsup.ai/lab/factory-skill"><img src="https://img.shields.io/badge/gallery-airsup.ai%2Flab%2Ffactory--skill-e2713a?style=flat-square" alt="Gallery"></a>
  9. </p>
  10. <p align="center">
  11. <img src=".github/assets/hero.gif" width="860" alt="A one line prompt is typed, a miniature e-bike motor factory assembles itself station by station, product flows on the conveyors and the HUD shows throughput against target and the bottleneck.">
  12. </p>
  13. ## Quick start
  14. ```sh
  15. npx skills add AirsupHQ/factory-skill -g -a claude-code
  16. ```
  17. Then, in Claude Code:
  18. ```text
  19. /factory a line that makes 2,000 e-bike motors a day
  20. ```
  21. No API keys and nothing to `npm install`: the scripts use only Node built-ins and the page is one
  22. self-contained HTML file.
  23. ## What it does
  24. Claude reads the line, writes the real process route (stations, cycle times, batches, breakdown
  25. rates, yields), sizes every station from demand, checks the line headless, and hands you **one HTML
  26. file**: a model factory on a table, seen through a tilt-shift lens, with machines that move while
  27. they work and product flowing between them. Under it runs a discrete event simulation. Every number
  28. on screen is computed by it:
  29. - **throughput** per day against the target, with a sparkline per production hour
  30. - **takt**, **WIP** and **lead time**
  31. - **utilization** of every station, split into busy, blocked, starved and down
  32. - the **bottleneck**, outlined in pulsing red on the floor
  33. Click a station: add a machine, slide its cycle time or its buffer, and watch the queue drain and
  34. the bottleneck move. The inspector shows the sizing formula with its numbers and a 3 day forecast of
  35. the changed line from the same engine.
  36. ## Gallery
  37. <table>
  38. <tr>
  39. <td width="33%"><img src=".github/assets/ebike-motors.jpg" alt="E-bike hub motor line"></td>
  40. <td width="33%"><img src=".github/assets/croissant-bakery.jpg" alt="Croissant bakery"></td>
  41. <td width="33%"><img src=".github/assets/battery-gigafactory.jpg" alt="Battery cell gigafactory"></td>
  42. </tr>
  43. <tr>
  44. <td><sub><b>"a line that makes 2,000 e-bike motors a day"</b><br>stator, rotor and hub shell branches joined at assembly</sub></td>
  45. <td><sub><b>"a bakery that bakes 10,000 croissants an hour"</b><br>proofers, a 14 m tunnel oven and a spiral cooler as continuous dwell</sub></td>
  46. <td><sub><b>"a battery cell gigafactory"</b><br>a 4 GWh line, coating to formation, three shifts</sub></td>
  47. </tr>
  48. <tr>
  49. <td><img src=".github/assets/drone-line.jpg" alt="Drone assembly line"></td>
  50. <td><img src=".github/assets/brewery-canning.jpg" alt="Brewery canning hall"></td>
  51. <td><img src=".github/assets/satellite-factory.jpg" alt="Satellite factory"></td>
  52. </tr>
  53. <tr>
  54. <td><sub><b>"a drone assembly line"</b><br>flight controller SMT branch, calibration, flight test cage</sub></td>
  55. <td><sub><b>"a craft brewery canning 6,000 cans an hour"</b><br>filler, tunnel pasteurizer, case packer, robot palletizer</sub></td>
  56. <td><sub><b>"a factory that builds 4 satellites a day"</b><br>cleanroom bays, gantry cranes, thermal vacuum in batches of 4</sub></td>
  57. </tr>
  58. </table>
  59. All six were made by Claude with this skill, from the prompts above. Open any
  60. `examples/*/*.html` in a browser, or try them at
  61. [airsup.ai/lab/factory-skill](https://www.airsup.ai/lab/factory-skill).
  62. ## Install
  63. The repository is the skill: a folder with a `SKILL.md` at its root.
  64. | | Command |
  65. |---|---|
  66. | skills CLI, for you | `npx skills add AirsupHQ/factory-skill -g -a claude-code` |
  67. | skills CLI, one project | `npx skills add AirsupHQ/factory-skill` |
  68. | git, for you | `git clone https://github.com/AirsupHQ/factory-skill.git ~/.claude/skills/factory` |
  69. | git, one project | `git clone https://github.com/AirsupHQ/factory-skill.git .claude/skills/factory` |
  70. Claude Code picks up new skills in a running session; if the `skills` folder did not exist when the
  71. session started, run `/reload-skills`.
  72. ### Other agents
  73. Factory follows the [Agent Skills](https://agentskills.io) format: a folder with a `SKILL.md` at its
  74. root, plain scripts and references beside it. Any host that loads that format can use it. The skills
  75. CLI installs it for other agents with `-a <agent>` (see `npx skills --help` for the list); in the
  76. Claude apps you can upload the folder as a zip under Settings, Capabilities, Skills; the Claude Agent
  77. SDK picks it up from `.claude/skills/`. The workflow needs a shell with Node 20 or later to run
  78. `check.mjs` and `build.mjs`; a host without one can still follow `SKILL.md` and write the spec.
  79. ## Usage
  80. ```text
  81. /factory a bakery that bakes 10,000 croissants an hour
  82. /factory a battery cell gigafactory, three shifts, 4 GWh
  83. /factory how many CNC machines do I need for 600 gearbox housings a week at 42 minutes each?
  84. ```
  85. You do not have to name the skill: asking to see, size or simulate a production line loads it.
  86. Give real numbers when you have them (volumes, cycle times, machines you already own, shifts);
  87. Claude fills the rest with typical values and says which ones it assumed.
  88. The headless tools work on their own too:
  89. ```sh
  90. node scripts/check.mjs examples/ebike-motors/spec.js # size the line and run 5 production days
  91. node scripts/build.mjs examples/ebike-motors/spec.js # write the self-contained page
  92. node scripts/capture.mjs examples/ebike-motors/ebike-motors.html shot.png --query assemble=0
  93. node scripts/record.mjs examples/ebike-motors/ebike-motors.html film.mp4 --secs 12 --query intro=1
  94. ```
  95. `check.mjs` prints, per station, machines, capacity per day, busy, down, blocked, starved and
  96. failures, then the forecast and the bottleneck:
  97. ```text
  98. station ct s batch mach cap/day busy down block starve fails
  99. > Lamination press 22 1 1 2,448 76% 12% 12% 0% 19
  100. Needle winding 150 1 7 2,481 74% 5% 9% 12% 140
  101. ...
  102. forecast over 5 production days: 1,943 motors/day (97% of target), scrap 29.6/day
  103. bottleneck: Lamination press (busy + down 88%) WIP at end 193 tokens lead time 72.6 min
  104. ```
  105. ## How it works
  106. | Layer | What it does |
  107. |---|---|
  108. | `SKILL.md` | The method: read the line, state assumptions, write the process route with real numbers, size, check, build, look, answer with the finding |
  109. | `runtime/des.js` | Event driven DES: parallel machines, lognormal cycles, batches, joins, finite buffers with blocking after service, operation dependent breakdowns, scrap, shift calendar, seeded and deterministic. Same file in Node and the browser |
  110. | `runtime/kit.js` | 27 machines at real scale with moving parts and stack lights, 29 product shapes, people, forklifts, AMRs, trucks, racks, trees |
  111. | `runtime/world.js` | Layout of the line (branches, joins, folding long lines), hall, yard, diorama base, and every token placed where the simulation says it is |
  112. | `runtime/look.js` | The miniature: warm sun and soft shadows, GTAO, bloom on emissive parts only, a tilted band of focus, warm saturated grade |
  113. | `runtime/app.js` | HUD, inspector, what-if API, film mode |
  114. | `vendor/three.bundle.js` | three.js r185 and the addons used, MIT |
  115. The model, its limits and the sizing rule are in [`references/des.md`](references/des.md); typical
  116. process numbers in [`references/process.md`](references/process.md); the kit API in
  117. [`references/kit.md`](references/kit.md); the look in [`references/look.md`](references/look.md).
  118. ## Requirements
  119. Node 20 or later for the scripts (built-ins only). A WebGL2 browser for the page. Playwright is
  120. optional, for `capture.mjs` and `record.mjs`.
  121. ## Limits
  122. One sink (no rework loops), no changeovers between variants, no shared labour pool, conveyors are
  123. buffers (material handling has no capacity of its own), and a breakdown of a continuous machine
  124. (tunnel oven, spiral) stops one slot rather than the whole machine. Numbers are as good as the cycle
  125. times Claude is given or estimates: the page shows its assumptions so you can change them.
  126. ## Credits
  127. Made by [airsup](https://www.airsup.ai), manufacturing simulation for hardware teams. Inspired by
  128. [Anatomy](https://github.com/wheresryan22/anatomy), the skill that brings machines to life as
  129. isometric figures. MIT licence.

Ratings and comments

Sign in to rate this skill.

Sign in

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