How to build a
factory.

A factory turns a fuzzy request into finished, double-checked work.

Most people ask an AI for everything at once: “Build me the whole thing.” It often misunderstands, skips a step, or invents something. A factory fixes that by breaking the job into small, labeled stations and laying them out as folders on your computer.

The AI opens the right folder, reads the short note inside, does only that one step, writes the result into an “out tray,” and then stops so you can look. You approve or correct it, and it moves to the next station. The folders are the machine — there’s nothing to install and nothing running in the background.

Because every step’s instructions live in their own little file, the AI only ever loads what it needs for the step it’s on. That’s the whole trick: small notes, clear order, and a human checkpoint between every step.

Example: If you ask an AI to "write me a landing page," it might miss your brand voice, skip mobile layout, or invent features you never mentioned. A factory breaks that into six small steps — explore what exists, clarify the offer, plan the layout, build it, review it, hand it off — and makes you check each one before the next begins. The result is closer to what you actually wanted, with a paper trail to prove it.

What’s inside the building.

Here is the whole factory as a floor plan. Every room is just a folder; every sign is just a plain text file. The next section explains each one.

Every folder has a plain-English job.

Six stations, with you between each one.

Inside a workshop, the job moves down a short assembly line. Each station does one thing and then hands its result to the next. The diamond between stations is you — the AI stops, shows you what it made, and waits for your “go.”

When something goes wrong: If a station finds a defect that started upstream, it doesn't patch it in place. It reports the issue and routes it back to the station that owns it. This routing discipline is where the factory's real value lives — it keeps problems from compounding downstream.

The job card: three short lists.

Every station folder holds one small note (a CONTEXT.md file). It always has the same simple shape — three lists and a “stop.” Once you’ve seen one, you’ve seen them all.

Habits that make a factory reliable.

You only need a folder and a text editor.

A factory is just folders and plain text files, so you can make one by hand — no coding. A .md file is simply a plain text file (the kind you’d make in Notepad or TextEdit); the “.md” just lets it carry light formatting like headings. Follow these eight steps.

The whole shape, ready to copy.

Here’s the full folder layout and a starter note for every file. Copy the layout to picture the finished factory, then use the templates to fill in each piece.

# Your finished factory — every line is a folder or a plain text file
my-factory/
├── INSTRUCTIONS.md      # the "Start Here" card (paste into your AI assistant)
├── CONTEXT.md           # the reception desk: which workshop for which job
├── _config/             # the settings binder — your rules & facts, set once
│   ├── voice-and-rules.md
│   └── facts.md
├── shared/              # the supply room — reusable parts & examples
│   ├── examples/
│   └── parts/
├── skills/              # the toolbox — short how-to cards
│   └── build-it/
│       └── SKILL.md
└── workspaces/           # the workshops — one per kind of job
    └── my-first-job/
        ├── input/        # IN TRAY — drop raw materials here
        ├── output/       # OUT TRAY — each station's result lands here
        ├── CONTEXT.md    # this workshop's station map
        └── stages/
            ├── 01-explore/   → CONTEXT.md
            ├── 02-clarify/   → CONTEXT.md
            ├── 03-plan/      → CONTEXT.md
            ├── 04-build/     → CONTEXT.md
            ├── 05-review/    → CONTEXT.md
            └── 06-handoff/   → CONTEXT.md

# My Factory — Start Here

You are my work partner. Help me
produce finished, double-checked work.

## How this place works
- Walk the numbered station folders
  in order, top to bottom.
- Do ONLY the current station's job.
- Write each result into that
  workshop's output/ folder.
- STOP after every station and show
  me the result. Wait for my "go."

## Where to start
- Read CONTEXT.md to pick the
  workshop, then start at station 01.

## Rules you must not break
- Recommend, then let me decide.
- Never invent facts. If something
  is missing, ask me.
- <add your own rules here>

# Station 04: Build

## Inputs  (what to read first)
- output/03-plan.md   (the plan)
- _config/voice-and-rules.md

## Process  (what to do here)
1. Read the plan and the rules.
2. Build exactly what the plan says.
3. Reuse parts from shared/.
4. Check your work against the rules
   and note anything off.

## Outputs  (what to produce)
- output/04-draft.md
  (the result, for the next station)

## Stop
Show me the draft. I approve or
correct it before station 05.

# Voice & Rules

## Tone
- Be direct and specific.
- Use plain language — no jargon
  unless the user asked for it.
- Be honest about uncertainty.

## Do's
- Ask before assuming.
- Show your work.
- Flag risks early.

## Don'ts
- Never invent facts. If something
  is missing, ask.
- Never skip a checkpoint.
- Never modify _config/ files
  without asking.

## Formatting
- Use headings to organize long
  outputs.
- Use bullet points for lists.
- Keep responses under 300 words
  unless detail is requested.

# Facts

## Product
- Name: [your product]
- What it does: [one sentence]
- Audience: [who uses it]

## Key URLs / paths
- [Add any fixed references here]

## Preferences
- Preferred stack / tools: [list]
- Deployment target:
  [e.g. local, cloud, specific platform]

# Skill: Build It

## When to use
Use this when you have an approved
plan and need to produce
the deliverable.

## Steps
1. Read the plan from output/03-plan.md.
2. Read the rules from
   _config/voice-and-rules.md.
3. Reuse parts from shared/ where
   possible.
4. Build exactly what the plan
   specifies.
5. Check your work against the rules.
6. Write the result to
   output/04-draft.md.

## Check
- Does the output match the plan?
- Did you reuse shared parts instead
  of reinventing?
- Did you follow all rules from
  _config/?

# Workshop: my-first-job

## What this workshop does
[One sentence describing the job
this workshop handles.]

## Station map
| Stage | Name     | What it does                       |
|-------|----------|------------------------------------|
| 01    | Explore  | Read the request, look around.     |
| 02    | Clarify  | Ask key questions, lock scope.     |
| 03    | Plan     | Write the one-page plan.           |
| 04    | Build    | Build to the approved plan.        |
| 05    | Review   | Inspect the draft as fresh eyes.   |
| 06    | Hand off | Produce the finished file.         |

## How to use
1. Drop raw materials into input/.
2. Start at stage 01.
3. After each stage, stop and show
   the result.
4. Continue on "go."

# Station 01: Explore

## Inputs (what to read first)
- input/  (the raw request)
- shared/examples/  (existing examples,
  if any)
- shared/parts/  (reusable parts,
  if any)

## Process (what to do here)
1. Read the request carefully.
2. Look through shared/ for anything
   that already exists.
3. Summarize what exists, what's
   missing, and what's unclear.
4. Do NOT build anything yet.

## Outputs (what to produce)
- output/01-exploration.md
  (summary of what you found, for
  the next station)

## Stop
Show me the exploration summary.
I confirm you understood the request
before moving to station 02.

# Station 02: Clarify

## Inputs (what to read first)
- output/01-exploration.md
  (the exploration summary)
- _config/facts.md  (product context)

## Process (what to do here)
1. Read the exploration summary.
2. Identify the 2-5 questions that
   matter most.
3. Ask me one question at a time.
4. After all answers, lock the scope
   in writing.

## Outputs (what to produce)
- output/02-scope.md
  (final scope: what's in, what's
  out, acceptance criteria)

## Stop
Show me the scope. I confirm it
before you write the plan.

# Station 03: Plan

## Inputs (what to read first)
- output/02-scope.md  (the locked scope)
- _config/voice-and-rules.md
  (the rules)
- shared/parts/  (reusable components)

## Process (what to do here)
1. Read the scope and the rules.
2. List exactly what will be built.
3. Note which shared parts to reuse.
4. Write a one-page plan with clear
   deliverables.

## Outputs (what to produce)
- output/03-plan.md
  (the plan, ready for approval)

## Stop
Show me the plan. I approve or
correct it before you build.