Factory skill

A skill that turns a one-line brief into a live 3D factory model with a discrete event simulation, throughput and bottleneck.

  • 51 ★ on the repository
  • Last commit
Skill

Extended access

Why this level

  • The skill runs Node scripts on your machine and writes HTML files.
All reasons and checks

airsuphq/factory-skill

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/airsuphq-factory-skill

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The skill runs Node scripts on your machine and writes HTML files.

This is third-party code. Review the repository files before installing.

What it does

Factory turns a line description into a single HTML file: a miniature factory on a table seen through a tilt-shift lens, with machines that move and product that flows on conveyors. A discrete event simulation runs underneath, and every number on screen is computed by it: daily throughput against target, takt, WIP, lead time, per-station utilization and the bottleneck outlined in red. Claude reads the brief, writes a real process route (stations, cycle times, batches, breakdowns, yields), sizes stations from demand and checks the line headless. On the page you can add a machine, slide a cycle time or buffer and watch the queue and bottleneck change. Scripts use only Node built-ins and no API keys are needed.

Who it is for. Production engineers and hardware startup founders who need a quick estimate of a line, machine count and bottleneck before buying equipment.

Good fit when

  • How many CNC machines are needed for 600 gearbox housings a week at 42 minutes each
  • A motor assembly line for 2,000 units a day must be shown to an investor visually
  • You want to see how the bottleneck moves if a second machine is added at assembly
  • A bakery or packing hall is modelled by hourly throughput
  • A standalone HTML file that opens without a server is required

Not a fit when

  • The line has rework loops or changeovers between variants: the model has a single sink without rework loops
  • You need a shared labour pool, which the model lacks
  • The browser lacks WebGL2: the page will not render

Example request

Build a line that makes 2,000 e-bike motors a day and show the bottleneck.

Limitations

The model has a single sink, no rework loops, no changeovers between variants and no shared labour pool. Conveyors are buffers with no capacity of their own. A breakdown of a continuous machine such as a tunnel oven stops one slot rather than the whole machine. Accuracy depends on cycle times supplied by the user or estimated by Claude: the page shows its assumptions so you can change them. You need Node 20 or later for the scripts and a WebGL2 browser. Playwright is only needed for screenshots and video recording. The model and sizing rule are described in `references/des.md`.

How to disable. Delete the skill folder: `~/.claude/skills/factory` or `.claude/skills/factory` in a project. Generated HTML files live separately and do not depend on the skill.

FAQ

How do I install Factory in Claude Code?

Run `npx skills add AirsupHQ/factory-skill -g -a claude-code`. The git option is `git clone https://github.com/AirsupHQ/factory-skill.git ~/.claude/skills/factory`.

Do I need API keys or dependencies?

No. Scripts use only Node built-ins and the page is one self-contained HTML file. Playwright is only needed for optional captures and video.

What if the skill did not load?

If the `skills` folder did not exist when the session started, run `/reload-skills`. Claude Code picks up new skills in a running session.

Where do the numbers on screen come from?

A discrete event simulation computes them: parallel machines, batches, finite buffers, breakdowns, scrap and a shift calendar. Claude fills missing data with typical values and states its assumptions.

Does it work with other agents?

Yes, the Agent Skills format fits any host that loads it. The `skills` installer accepts `-a <agent>`, and in Claude apps the folder can be uploaded as a zip.

Discussion

No questions or reviews yet.

Skills

A skill for math modeling contests CUMCM, MCM/ICM and the Electrical Cup: 10 stages, three roles, five gates and a LaTeX paper

SkillExtended access73Repository stars

24 skills for numerical methods and materials science: the agent checks stability, meshes, convergence and cluster runs.

PluginExtended access83Repository stars

A skill that picks a scientific chart from nearly 100 templates for CSV or Excel data and outputs PNG, SVG, PDF and Python code.

SkillExtended access298Repository stars

A data visualization skill for agents: turns data into polished interactive HTML charts and full reports with one visual language

SkillMinimal access6.8KRepository stars

A three-stage workflow for math modeling tasks: analysis and model choice, Python or MATLAB computation, and paper assembly in Word or LaTeX

SkillExtended access1.9KRepository stars

DDC Skills for Construction

DDC Skills for AI Agents in Construction

238 skills for construction companies: BIM to Excel export, cost item search, estimates, site reports and document generation

SkillExtended access405Repository stars

README in short

The README covers installation, sample prompts, a gallery of six finished factories, commands that run without an agent, the repository layout and model limits. The author is Airsup, which builds manufacturing simulation.

README badge

Original SKILL.md

---
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/`.

Report a problem