factory
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.
Badge for your README
Markdown
[](/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
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)
- ---
- name: factory
- 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".
- ---
- # Factory
- **Describe a factory in one line. Claude builds it as a live 3D simulation you can run.**
- The page is a model factory on a table, seen through a tilt-shift lens: a cut-away hall with
- the line inside, machines that move while they work, product flowing on conveyors, people, forklifts, a
- truck yard. Under it runs a discrete event simulation. Every number on screen comes from that
- simulation, never from a script: the throughput, the utilization bars, the WIP, the pulsing red
- outline around the bottleneck. When someone adds a machine at the bottleneck, the simulation gets
- one more server, the conveyor in front of it drains, and the outline moves to the next constraint.
- ## The one rule that matters
- **The simulation is the explanation, so it has to be true.**
- - Cycle times, batch sizes, dwell times, breakdown rates and yields come from how the real process
- works. Use the numbers a process engineer would recognise and say in `note` where they come from
- ("18 min at 180 C", "51 slots, 3 needle head"). When you have to estimate, say "typical".
- - Machine counts come from the sizing rule, which the page prints in the inspector:
- `machines = CEIL(rate_in x cycle / (batch x availability x target utilization))`.
- - Throughput, utilization and the bottleneck come out of the simulation. Never tune inputs to make
- a nicer result. If the first line misses its target, that is the finding: report it, show it, and
- let the user fix it with the slider.
- ## Workflow
- Run `date` at the start. A factory takes 10 to 25 minutes.
- 1. **Read the line.** Pull out the product, the volume and the time unit. Fill in what is missing with
- stated assumptions: shifts (2 x 8 h unless the process runs around the clock, like cells,
- chemicals or glass), the product variant ("250 W rear hub motor"), the scope ("the canning hall,
- from bright tanks to pallets"). Say them in one short paragraph before building.
- 2. **Route.** Write the real process route as 6 to 10 stations, in flow order, with branches where
- sub-assemblies are made in parallel and joined (stator + rotor + housing into motor assembly).
- Each station: what happens, the machine that does it, the cycle time per unit or per batch, the
- batch, MTBF/MTTR if it is a machine that breaks, yield if it is a test or inspection.
- `references/process.md` has typical numbers for common processes and how to pick them.
- 3. **Pick the token.** One token is one unit unless the line is fast. Choose `perToken` so one token
- leaves the line every 5 s to 2 h (a tray of 40 croissants, a case of 24 cans, a tray of 96 cells).
- 4. **Write `spec.js`** (schema below). Start from the closest example in `examples/`.
- 5. **Check it headless.** `node scripts/check.mjs spec.js`. It sizes the line and runs 5 production
- days of the same engine the page runs, and prints per station: machines, capacity per day, busy,
- down, blocked, starved, failures; then the forecast and the bottleneck. Read it like an engineer:
- - Does each machine count look like a real plant? 446 proofer slots is right (4 chambers of 120);
- 40 laminators is a wrong cycle time.
- - Is the bottleneck plausible? Long dwell steps and machines with poor availability usually are.
- - Fix mistakes in the inputs (a wrong unit, a batch you forgot). Do not fix the result.
- 6. **Build.** `node scripts/build.mjs spec.js <out>.html` writes one file of about 1 MB with three.js,
- the runtime and the spec inlined. It opens from disk with no server and no network.
- 7. **Look at it.** `node scripts/capture.mjs <out>.html shot.png --query "assemble=0"` (needs
- Playwright) and read the PNG. The line should fill the frame, every station should have its
- machines, product should be on the conveyors, the HUD should show a throughput. Zero console errors.
- 8. **Answer** with the file path, the forecast against the target, the bottleneck and why, the sizing
- of the bottleneck station, and one what-if to try ("add a third winder: the forecast goes from
- 1,943 to 2,0xx a day and the constraint moves to EOL test"). Run that what-if through
- `check.mjs` (edit `servers` on a copy) before you quote it.
- ## Spec
- ```js
- FactorySkill.define({
- id: 'ebike-motors', // file name
- prompt: 'a line that makes 2,000 e-bike motors a day', // the user's line, typed into the page
- title: 'E-bike hub motor line',
- product: { name: 'motor', unit: 'motors', perToken: 1 },
- demand: { perDay: 2000 }, // or perHour, or perWeek (5 days)
- calendar: { shifts: 2, hoursPerShift: 8, startHour: 6 },
- sizing: { targetUtil: 0.85 }, // planned utilization for the sizing rule
- release: 'capacity', // 'capacity': raw material always there (find the max), 'takt': released at demand
- seed: 11,
- stations: [
- { id: 'stamp', name: 'Lamination press', machine: 'press', ct: 22, cv: 0.04, buffer: 8,
- mtbf: 6 * 3600, mttr: 25 * 60, input: 'coil', stage: 'stack', note: '64 laminations at 180 strokes/min' },
- { id: 'wind', name: 'Needle winding', machine: 'winder', ct: 150, after: ['stamp'], stage: 'wound' },
- ...
- ],
- stages: { coil: { shape: 'coil', color: '#8d949b' }, stack: { shape: 'ring', color: '#6f7780' }, ... },
- })
- ```
- Station fields:
- | field | meaning |
- |---|---|
- | `id`, `name` | key and the name on the plate and in the HUD |
- | `machine` | a kit machine (table below) or an alias such as `lathe`, `proofer`, `pasteurizer`, `seamer` |
- | `ct` | seconds per cycle per machine; with `batch` it is the time for the whole batch |
- | `cv` | coefficient of variation of the cycle (lognormal). Automatic 0.02 to 0.06, manual 0.1 to 0.2 |
- | `batch` | units taken and released together (a chamber oven, a mixer, a TVAC) |
- | `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 |
- | `servers` | `'auto'` (default, sizing rule) or a number of machines (times `perMachine`) |
- | `buffer` | capacity of the input buffer (each input of a join has its own) |
- | `mtbf`, `mttr` | mean busy seconds between failures and mean repair seconds (exponential) |
- | `yield` | fraction good; the rest is scrapped at this station |
- | `after` | predecessor ids. Default: the previous station. A station with `input` starts a new branch |
- | `input` | the raw material stage a branch starts from |
- | `stage` | the product stage this station outputs (looks up `stages`) |
- | `note` | where the numbers come from, shown in the inspector |
- | `variant`, `color`, `accent`, `length`, `radius`, `height`, `fill`, `web`, `glow` | looks |
- | `operators`, `reserve`, `at: [col, row, dir]` | people beside machines, spare floor slots, manual grid placement |
- The model is a tree into one last station (the sink): every station feeds exactly one next station.
- ## Kit
- Machines (real scale, metres) in `runtime/kit.js`:
- | machine | looks like | kind |
- |---|---|---|
- | `cnc` | machining centre, window, moving spindle, chip conveyor | side |
- | `press` | press with ram and flywheel, coil feeder; `variant: 'magnetizer'` | side |
- | `winder` | needle winder, spinning table, wire spools | side |
- | `robot` | fenced 6 axis arm cell; `variant: 'weld'` adds arc and sparks | side |
- | `bench` | assembly bench with an operator, bins, tool balancer | side |
- | `tester` | test rack with screens and a clamp fixture | side |
- | `oven` | chamber oven with racks (batch); `variant: 'proofer'` | side |
- | `mixer` | spiral or planetary mixer with turning bowl | side |
- | `filler` | rotary filler / seamer in a glass enclosure | side |
- | `formation` | racks with blinking channels (formation, ageing, burn-in) | side |
- | `tank` | stainless tank with agitator, ladder, piping | side |
- | `laser` | laser cell with glowing window | side |
- | `turntable` | calibration turntable with camera tripods | side |
- | `cage` | flight / function test cage; the unit lifts while tested | side |
- | `bay` | integration bay with gantry crane and technicians; `variant: 'cleanroom'` | side |
- | `chamber` | thermal vacuum / autoclave vessel with a round door (batch) | side |
- | `kitting` | shelving with bins and a picker | side |
- | `stacker` | high speed stacking / winding head | side |
- | `cell` | generic enclosed process cell (anything else) | side |
- | `tunnel` | tunnel oven, dryer; `variant: 'pasteurizer' | 'washer'` | inline |
- | `spiral` | spiral cooler / freezer / proofer tower | inline |
- | `rollers` | sheeter, laminator, `variant: 'calender' | 'slitter'` | inline |
- | `coater` | roll to roll coater with drying oven | inline |
- | `smt` | printer + pick and place + reflow | inline |
- | `vision` | inspection arch over a belt | inline |
- | `packer` | case packer / flow wrapper | inline |
- Product shapes for `stages`: `ring wound rotor hub disc coil box crate tote croissant tray dough sheet
- can sixpack bottle cell pouch roll module pack pcb frame drone satellite bus sneaker bag puck`.
- Each takes `color` and `scale`; `tray` takes `item: 'croissant' | 'dough'`.
- A process with no fitting machine: use `cell` with a `glow` colour, or define one in the spec file
- before `define` (guarded, so `check.mjs` can run the file without a browser):
- ```js
- if (FactorySkill.Kit) FactorySkill.Kit.def('kiln', (o) => {
- const K = FactorySkill.Kit, { g, M, body, acc } = K.sideBase(o, 3, 2.4)
- K.box(g, 3, 2.2, 2.2, body, 0, 0, 0) // K.box(parent, w, h, d, material, x, yBottom, z)
- const door = K.live(K.group(g, 0, 0, -1.1)) // parts that move live in K.live groups
- K.box(door, 1.4, 1.6, 0.08, acc, 0, 0.3, 0)
- return K.finish({ g, kind: 'side', w: 3, d: 2.4, h: 2.4, entry: K.V(0, 0.9, -1.3),
- 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])
- })
- ```
- `references/kit.md` has the whole API (materials, parts, people, vehicles, `work(i, p)` for units that
- move through a machine).
- ## The page
- - Opens on the assembled factory, already 3 production hours in (more for slow lines) so buffers hold
- WIP. `?intro=1` types the prompt and assembles the factory station by station first.
- - HUD: throughput per day over the last 4 h against the target, a sparkline per production hour,
- takt, WIP, lead time, the bottleneck card, one bar per station split into busy, blocked, starved and
- down. The bottleneck station gets a pulsing red outline on the floor; nothing else is labelled.
- - Click a station (or its row) for the inspector: machines with minus and plus (spare floor is
- reserved), cycle time and buffer sliders, the sizing formula with its numbers, MTBF/MTTR, failures,
- scrap, and a 3 day forecast of the changed line from the same engine.
- - Speed buttons scale production time; the clock shows day, time and shift.
- - `?film=1` stops the clock: `window.__film.step(dt)` renders one frame. `window.factory` exposes
- `select(id)`, `setMachines(id, n)`, `setCT(id, s)`, `setBuffer(id, n)`, `camTo({az, el, dist, target}, s)`,
- `stationCenter(id)`, `forecast()`, `sim`, `world`.
- - Other URL options: `speed`, `seed`, `release=takt`, `select=<id>`, `ui=0`, `assemble=0`, `ao=0`.
- ## Look
- Tilt-shift miniature photography, not a CAD view: warm sun with soft shadows, ambient occlusion, a
- narrow band of focus with heavy blur above and below, saturated warm grade, vignette, grain. The
- factory sits on a diorama base on a table: cut-away hall (back and left walls full height, front and
- right cut low with the section face coloured), racking along the back wall, clutter on free floor,
- truck yard, parking, trees, a sign. Machines are cream with one accent colour per station.
- `references/look.md` explains each choice and what to keep when you extend it.
- ## Verify like a critic
- - `check.mjs` numbers match the HUD after a few hours (the HUD window is 4 h, so it is noisier).
- - Every station shows its machines; nothing floats; tokens sit on belts or in machines.
- - At the bottleneck the input buffer is full and machines upstream show amber (blocked); downstream
- rows show grey (starved). If not, the bottleneck is downtime driven: say so.
- - Add a machine at the bottleneck in the page: the forecast line updates and the outline moves within
- about an hour of production time.
- ## Files
- | path | what |
- |---|---|
- | `runtime/des.js` | the simulation engine and the sizing rule (pure, runs in Node and the browser) |
- | `runtime/kit.js` | machines, products, people, vehicles |
- | `runtime/world.js` | layout, hall, conveyors, token placement from simulation state |
- | `runtime/look.js` | renderer, light, AO, bloom, tilt-shift, grade |
- | `runtime/app.js`, `runtime/hud.css` | page, HUD, inspector, film hooks |
- | `vendor/three.bundle.js` | three.js r185 and the addons used (MIT) |
- | `scripts/check.mjs`, `scripts/build.mjs`, `scripts/capture.mjs` | headless run, build, screenshot |
- | `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)
- <h1 align="center">Factory</h1>
- <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>
- <p align="center">
- <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>
- <a href="https://agentskills.io"><img src="https://img.shields.io/badge/Agent_Skills-compatible-24262a?style=flat-square" alt="Agent Skills compatible"></a>
- <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-24262a?style=flat-square" alt="MIT license"></a>
- <a href="#requirements"><img src="https://img.shields.io/badge/dependencies-0-24262a?style=flat-square" alt="No dependencies"></a>
- <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>
- </p>
- <p align="center">
- <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.">
- </p>
- ## Quick start
- ```sh
- npx skills add AirsupHQ/factory-skill -g -a claude-code
- ```
- Then, in Claude Code:
- ```text
- /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 it does
- Claude reads the line, writes the real process route (stations, cycle times, batches, breakdown
- rates, yields), sizes every station from demand, checks the line headless, and hands you **one HTML
- file**: a model factory on a table, seen through a tilt-shift lens, with machines that move while
- they work and product flowing between them. Under it runs a discrete event simulation. Every number
- on screen is computed by it:
- - **throughput** per day against the target, with a sparkline per production hour
- - **takt**, **WIP** and **lead time**
- - **utilization** of every station, split into busy, blocked, starved and down
- - the **bottleneck**, outlined in pulsing red on the floor
- Click a station: add a machine, slide its cycle time or its buffer, and watch the queue drain and
- the bottleneck move. The inspector shows the sizing formula with its numbers and a 3 day forecast of
- the changed line from the same engine.
- ## Gallery
- <table>
- <tr>
- <td width="33%"><img src=".github/assets/ebike-motors.jpg" alt="E-bike hub motor line"></td>
- <td width="33%"><img src=".github/assets/croissant-bakery.jpg" alt="Croissant bakery"></td>
- <td width="33%"><img src=".github/assets/battery-gigafactory.jpg" alt="Battery cell gigafactory"></td>
- </tr>
- <tr>
- <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>
- <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>
- <td><sub><b>"a battery cell gigafactory"</b><br>a 4 GWh line, coating to formation, three shifts</sub></td>
- </tr>
- <tr>
- <td><img src=".github/assets/drone-line.jpg" alt="Drone assembly line"></td>
- <td><img src=".github/assets/brewery-canning.jpg" alt="Brewery canning hall"></td>
- <td><img src=".github/assets/satellite-factory.jpg" alt="Satellite factory"></td>
- </tr>
- <tr>
- <td><sub><b>"a drone assembly line"</b><br>flight controller SMT branch, calibration, flight test cage</sub></td>
- <td><sub><b>"a craft brewery canning 6,000 cans an hour"</b><br>filler, tunnel pasteurizer, case packer, robot palletizer</sub></td>
- <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>
- </tr>
- </table>
- All six were made by Claude with this skill, from the prompts above. Open any
- `examples/*/*.html` in a browser, or try them at
- [airsup.ai/lab/factory-skill](https://www.airsup.ai/lab/factory-skill).
- ## Install
- The repository is the skill: a folder with a `SKILL.md` at its root.
- | | Command |
- |---|---|
- | skills CLI, for you | `npx skills add AirsupHQ/factory-skill -g -a claude-code` |
- | skills CLI, one project | `npx skills add AirsupHQ/factory-skill` |
- | git, for you | `git clone https://github.com/AirsupHQ/factory-skill.git ~/.claude/skills/factory` |
- | git, one project | `git clone https://github.com/AirsupHQ/factory-skill.git .claude/skills/factory` |
- Claude Code picks up new skills in a running session; if the `skills` folder did not exist when the
- session started, run `/reload-skills`.
- ### Other agents
- Factory follows the [Agent Skills](https://agentskills.io) format: a folder with a `SKILL.md` at its
- root, plain scripts and references beside it. Any host that loads that format can use it. The skills
- CLI installs it for other agents with `-a <agent>` (see `npx skills --help` for the list); in the
- Claude apps you can upload the folder as a zip under Settings, Capabilities, Skills; the Claude Agent
- SDK picks it up from `.claude/skills/`. The workflow needs a shell with Node 20 or later to run
- `check.mjs` and `build.mjs`; a host without one can still follow `SKILL.md` and write the spec.
- ## Usage
- ```text
- /factory a bakery that bakes 10,000 croissants an hour
- /factory a battery cell gigafactory, three shifts, 4 GWh
- /factory how many CNC machines do I need for 600 gearbox housings a week at 42 minutes each?
- ```
- You do not have to name the skill: asking to see, size or simulate a production line loads it.
- Give real numbers when you have them (volumes, cycle times, machines you already own, shifts);
- Claude fills the rest with typical values and says which ones it assumed.
- The headless tools work on their own too:
- ```sh
- node scripts/check.mjs examples/ebike-motors/spec.js # size the line and run 5 production days
- node scripts/build.mjs examples/ebike-motors/spec.js # write the self-contained page
- node scripts/capture.mjs examples/ebike-motors/ebike-motors.html shot.png --query assemble=0
- node scripts/record.mjs examples/ebike-motors/ebike-motors.html film.mp4 --secs 12 --query intro=1
- ```
- `check.mjs` prints, per station, machines, capacity per day, busy, down, blocked, starved and
- failures, then the forecast and the bottleneck:
- ```text
- station ct s batch mach cap/day busy down block starve fails
- > Lamination press 22 1 1 2,448 76% 12% 12% 0% 19
- Needle winding 150 1 7 2,481 74% 5% 9% 12% 140
- ...
- forecast over 5 production days: 1,943 motors/day (97% of target), scrap 29.6/day
- bottleneck: Lamination press (busy + down 88%) WIP at end 193 tokens lead time 72.6 min
- ```
- ## How it works
- | Layer | What it does |
- |---|---|
- | `SKILL.md` | The method: read the line, state assumptions, write the process route with real numbers, size, check, build, look, answer with the finding |
- | `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 |
- | `runtime/kit.js` | 27 machines at real scale with moving parts and stack lights, 29 product shapes, people, forklifts, AMRs, trucks, racks, trees |
- | `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 |
- | `runtime/look.js` | The miniature: warm sun and soft shadows, GTAO, bloom on emissive parts only, a tilted band of focus, warm saturated grade |
- | `runtime/app.js` | HUD, inspector, what-if API, film mode |
- | `vendor/three.bundle.js` | three.js r185 and the addons used, MIT |
- The model, its limits and the sizing rule are in [`references/des.md`](references/des.md); typical
- process numbers in [`references/process.md`](references/process.md); the kit API in
- [`references/kit.md`](references/kit.md); the look in [`references/look.md`](references/look.md).
- ## Requirements
- Node 20 or later for the scripts (built-ins only). A WebGL2 browser for the page. Playwright is
- optional, for `capture.mjs` and `record.mjs`.
- ## Limits
- One sink (no rework loops), no changeovers between variants, no shared labour pool, conveyors are
- buffers (material handling has no capacity of its own), and a breakdown of a continuous machine
- (tunnel oven, spiral) stops one slot rather than the whole machine. Numbers are as good as the cycle
- times Claude is given or estimates: the page shows its assumptions so you can change them.
- ## Credits
- Made by [airsup](https://www.airsup.ai), manufacturing simulation for hardware teams. Inspired by
- [Anatomy](https://github.com/wheresryan22/anatomy), the skill that brings machines to life as
- isometric figures. MIT licence.
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.