Field Guide · no coding required

How to build a
factory.

A “factory” sounds technical. It isn’t. It’s just a folder of plain notes that walks your AI assistant through a job — one numbered step at a time — and stops for you to check the work between each step. This guide shows you how to build one yourself.

0 apps to install 1 folder on your computer Folders + text files only 30 min to your first one

01 The idea, in plain words

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.

02 The floor plan

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.

FIG. 1 — FACTORY FLOOR PLANfolders & notes only
CLAUDE.md ▸ the master instructions ▸ pinned to the front door CONTEXT.md ▸ the reception desk: “for X, go to room Y” _config/ the settings binder — rules & facts, set once shared/ the supply room — reusable parts, examples skills/ the toolbox — short how-to cards workspaces/ · THE WORKSHOPS (one per kind of job) input/ IN TRAY drop raw materials 01–02 explore · clarify 03–04 plan · build 05–06 review · hand off ◆ YOU CHECK THE WORK AT EVERY STOP ◆ output/ Each station writes its result to the OUT TRAY. The next station reads it from there — that hand-off is the entire “memory” of the factory.
Nothing here is software. Every box is a folder; every label is a plain text file you can open and edit.
03 The parts, one by one

Every folder has a plain-English job.

CLAUDE.md
The “Start Here” card

A note pinned to the front door. It tells the AI who it’s helping, how the place works, the naming habits, and the rules it must never break. This is the one note that’s always open.

CONTEXT.md
The reception desk

A tiny directory. It says, in effect, “If you want to do this, go to that workshop and start at station 01.” Its only job is pointing the AI to the right place.

_config/
The settings binder

The facts and rules you write down once: your tone of voice, your do’s and don’ts, any fixed values. Set it up at the start and reuse it on every job. Change a rule here and the whole factory follows it.

shared/
The supply room

Reusable parts, finished examples, and reference material — kept in one place so there’s a single correct copy of each. The AI pulls from here instead of reinventing things.

skills/
The toolbox

A few short “how-to” cards for jobs you repeat — like “how to build one” or “how to inspect one.” Each is a small note the AI can pick up and follow.

workspaces/
The workshops

One workshop per kind of job. Each holds an in tray (input/), a row of numbered stations (stages/01…06), and an out tray (output/). This is where the work actually happens.

04 How the work flows

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

01
Look first

Explore

Read the request and look around the supply room. Figure out what already exists and what’s needed. No building yet.

Checkpoint: you confirm it understood the job.
02
Ask, don’t assume

Clarify

Ask you the few questions that actually matter — one at a time — and lock down exactly what’s in and out of scope.

Checkpoint: you lock the scope.
03
Write the plan

Plan / Spec

Turn the answers into a one-page plan: what gets built, which parts get reused, what the rules require. Still no building.

Checkpoint: you approve the plan before anything is made.
04
Make it

Build

Build to the approved plan, reusing the supply-room parts. The AI checks its own work against the rulebook as it goes.

Checkpoint: you look at the draft.
05
Inspect

Review

A fresh pass, as an inspector — not the builder. It checks the result against the plan and flags problems by how serious they are.

Checkpoint: you decide which fixes to make.
06
Deliver

Hand off

Produce the finished file plus a short summary of what changed and anything that still needs a human sign-off. Done.

05 What’s on each station’s note

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.

STATION 04 · BUILDjob card · CONTEXT.md

A Inputs

What to read before starting — usually the previous station’s out-tray result, plus the rules that apply.

B Process

The steps to follow for this station, and nothing more. Short and specific, so the AI stays in its lane.

C Outputs

Exactly what to produce and where to put it — a named file dropped into the out tray for the next station.

Stop Show me the result. I approve or correct it before the next station begins.
06 Why it works

Seven habits that make a factory reliable.

Look before you buildNo work happens until the plan is approved. Misunderstandings get caught while they’re still cheap to fix.
You’re the inspectorThe AI recommends; you decide. There’s a human checkpoint after every station — never a straight shot to the end.
Everything is a plain noteEvery result is a readable file you can open, check, and edit. Nothing is hidden inside the machine.
One correct copyEach rule and reusable part lives in exactly one place. Fix it once and the whole factory updates.
The builder doesn’t grade itselfThe review station is a separate step with fresh eyes — no “marking your own homework.”
Only read what this step needsEach note loads just its own materials, so the AI stays focused and doesn’t drift off course.
Set it up once, use it foreverYou build the factory a single time. After that, every new job just runs through it.
Numbered order, every timeFolder numbers are the running order. The same job runs the same way, start to finish, repeatably.

07 Build your own — step by step

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.

Make the main folder

On your Desktop, create one new folder and name it my-factory. Everything lives inside it.

How to make a folderWindows: right-click the Desktop → New → Folder.  Mac: right-click the Desktop → New Folder.

Add the rooms

Inside my-factory, make four more folders: _config, shared, skills, and workspaces. These are your settings binder, supply room, toolbox, and workshops.

Write the “Start Here” card

In my-factory, create a text file named CLAUDE.md. In plain words, tell the AI who it’s helping, that it should walk the stations in order and stop after each one, and list any rules it must never break. (Use the starter on the right.)

How to make a text fileWindows: open Notepad, then Save As and type the name with quotes — "CLAUDE.md" — so it doesn’t add “.txt”.  Mac: open TextEdit, choose Format → Make Plain Text, then save as CLAUDE.md.

Write the reception sign

Next to it, create CONTEXT.md. Keep it tiny: a short list that says which workshop to use for which kind of request, and to start at station 01.

Build your first workshop

Inside workspaces, make a folder for your job (e.g. my-first-job). Inside that, make three folders: input, output, and stages. Inside stages, make six folders: 01-explore through 06-handoff. Drop one CONTEXT.md job card into each — three short lists and a “stop” (use the template on the right).

Write down your rules once

In _config, add a file or two for the things that never change — your tone of voice, your do’s and don’ts, any fixed facts. This is what makes the factory yours, and you only do it once.

Connect it to your AI

Open your AI assistant and start a Project. Paste the contents of your CLAUDE.md into its custom instructions so it’s always loaded. If your plan lets the AI read files on your computer, point it at the my-factory folder; if not, you can upload the folder or paste files in as you go.

Worth checking first The exact way to give an AI access to a folder depends on the tool and your plan. If you’re in a workplace, confirm with whoever manages your software what’s allowed — especially before using any real or sensitive material.

Run it

Drop your raw materials into the workshop’s input folder, then tell the AI what you want — for example, “Build the thing described in my-first-job, starting at station 01.” It reads the Start Here card, goes to station 01, does the work, and stops for you to check. Approve, and it walks the rest of the line.

08 Copy-paste starters

The whole shape, ready to copy.

Here’s the full folder layout and two starter notes. Copy the layout to picture the finished factory, then use the two templates to fill in your “Start Here” card and your first job card.

# Your finished factory — every line is a folder or a plain text file
my-factory/
├── CLAUDE.md            # the "Start Here" card (also paste into your AI Project)
├── 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

Starter: CLAUDE.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>

Starter: a station's CONTEXT.md

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

Before you trust it with real work

A factory organizes and documents the work beautifully — but it can’t force anything. Every rule is a polite instruction the AI follows, not a lock. That makes your judgment the most important part of the system, especially for anything sensitive or regulated.

  • Keep your human sign-off. The factory is a helper and a paper trail, not an approval. Final review still belongs to you and the right people.
  • Mind what you put in. Don’t feed it confidential or regulated material until you’ve confirmed your tool’s data-handling and cleared it with whoever needs to clear it.
  • Still test the real output. Whatever it produces, verify it the way you normally would — the factory documents the work, it doesn’t guarantee the result.
  • Grow it from real misses. Each time the AI gets something wrong, add one line to a rules file. The factory gets smarter every time you use it.