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

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:

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:

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):

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

Quick start

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 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

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.

Install

The repository is the skill: a folder with a SKILL.md at its root.

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 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

/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:

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:

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

The model, its limits and the sizing rule are in references/des.md; typical process numbers in references/process.md; the kit API in references/kit.md; the look in 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, manufacturing simulation for hardware teams. Inspired by Anatomy, the skill that brings machines to life as isometric figures. MIT licence.