Course · Available now

Software Factory

Thirty-three lessons and three projects on running coding agents as a delivery line instead of a pile of sessions: queues and gates, plan-the-release slicing, autonomy set per lane, an independent reviewer that never holds the merge key, holdouts with exact figures, protected paths, risk lanes, deterministic nodes around agent nodes, readiness scoring, staging and rollback, a registry and identity layer, outcome metrics, and the public failure record. The published factories are studied side by side, and the last module turns the line inward: a second loop that improves the procedures, a fact store that keeps provenance, and model routing proven by benchmarks.

You end withA factory/ directory for your own repo: line map, release slice, autonomy map, review gate, holdout set, protected paths, risk lanes, blueprint, readiness score, release path, registry, identity ledger, context map, scoreboard, incident lessons, and a charter that ties them together.

Start ifA coding agent already opens pull requests for you and the question is how many of them may merge without a person reading every line.

Take these courses first

  • Agent Fleets. A factory is a fleet with a merge policy. This course assumes you can already contain, isolate and review several agents, and adds the delivery line, the gates and the wrapper around them.
  • Loop Engineering. The gates in this course lean on a locked scorer and a ratchet. Loop Engineering teaches how to keep the measuring stick honest before a line runs unattended.
  • Harness Engineering. Required via Agent Fleets and Loop Engineering.
Level
Advanced
Lessons
33
Project labs
3
Modules
7
Reading
~14h

The loop you learn

Slice → Gate → Run → Wrap → Prove

Every lesson has the same shape.

You know what you are buying before you buy it.

01The failure

A specific factory that broke or stalled, with the symptom and what it cost, before any term is introduced.

02The rule

The smallest rule with its condition, and what it costs to follow.

03The build

The file in your factory/ directory, in full, inline, with a validator that fails on empty cells.

04The limit

What the evidence does not show, labelled self-reported, secondhand, vendor-hosted or contested.

Why it is built this way.

Three decisions that shaped every lesson.

A queue without a gate is a pile

Throughput only counts where a named approver and a written check sit between stages. Add the gate before you add the agent.

Autonomy is earned per lane, not granted per company

A lane runs unattended when a check that can say no and a revert that can say undo both exist. Every lane without them stays human-led.

Published numbers are self-reported until someone else measures them

No company publishes merge rate, revert rate or cost per merged PR with a denominator. Copy the mechanic, measure your own numbers.

33 lessons and 3 labs in 7 modules.

The whole path is public, and every lesson is free to read. Saving progress and the labs are what the paid tiers unlock.

MOD 01Slice the release

Draw the delivery line as queues and gates, plan the release as the unit of work, and set how much autonomy each lane earns, including when not to go dark.

MOD 02Gate the merge

Decide when an unattended change may merge: an independent reviewer that never holds the merge key, holdouts with exact figures, protected paths, and risk lanes that say when a human must read it.

MOD 03Run the line

Wrap agent steps in deterministic nodes with capped retries, score a repo before autonomy goes on, and land work through staging with a rollback owner.

MOD 04Wrap the fleet

The platform layer around the line: one owner and version per skill, every agent commit traced to a named human, and the context a repo cannot give. Taught as mechanisms, because no source measures their outcomes.

MOD 05Prove it

Measure outcomes, not the share of AI-written code, turn the public failure record into your gate tests, and assemble one factory charter for a real repository.

MOD 06Inside the factories

How ten companies run their factories, side by side: what each publishes, what each leaves out, what you can adopt for a solo, small-team, enterprise or regulated setting, and what every one of them shares.

MOD 07The factory that improves itself

Once the line runs, the only thing that compounds is what it learns: a second loop reads the first one's runs and human corrections, proposes reviewed changes to the procedure files, keeps a fact store with provenance and a retirement date, and pays a different price per task class, with the review gate, the curation and the benchmark that keep an improvement from becoming drift.

Start with the free lesson.

Engineers and tech leads who already run coding agents on real repositories and need to decide how much of the delivery line may run without a human reading the change.

  • One-time price, lifetime updates
  • Every course included — this one and the next
  • 30-day money-back guarantee
  • No card required to start