Software FactoriesExpert · Subscribers

Build a software factory you'd trust with your repo

You build the brakes first: a sandbox, hooks, hidden tests and a kill switch. Then the triggers. You finish with a line that takes a labeled issue to a verified draft PR, and a human merges it.

22
Tutorials
13h+
Guided content
Subscription
Access

Who it's for

  • Engineers who already use Claude Code and want it to run without them
  • Tech leads deciding which work belongs on an unattended line, and which never does
  • Platform and DevOps engineers wiring agents into GitHub Actions and CI
  • Anyone who needs a cost per merged PR before saying yes to agents

What you'll be able to do

  • Audit your backlog for factory fit and map the line: stations, handoffs and stop conditions (T1103, T1104)
  • Run Claude Code headless with claude -p, tool allowlists and budgets, and turn issues into JSON work orders with --json-schema (T1106, T1107)
  • Enforce rules with hooks and contain the builder in a non-root Docker sandbox, then prove it against a planted prompt injection (T1108–T1110)
  • Verify with holdout tests the builder never sees, an independent verifier and a tamper gate (T1111, T1112)
  • Write an Agent SDK builder–verifier loop with round and budget caps, worktrees and clean escalation (T1114, T1115)
  • Trigger from GitHub labels, schedules and API calls, then track cost per merged PR, DORA metrics and a kill switch (T1116–T1120)
Hands-on

What you'll build

01

A Haiku triage station that turns GitHub issues into validated JSON work orders

02

Hook gates plus a Docker sandbox with one allowed host, tested with a red-team drill

03

A verify script with holdout scenarios and a test-tamper check

04

A TypeScript Agent SDK orchestrator that runs builder, verifier and retries under caps

05

A GitHub line where a 'factory' label produces a verified draft PR that a human merges

Syllabus

22 tutorials, in order

  1. 01
    Sixty Years of Software Factories: Scope, Not Scale

    From Bemer's 1968 'software factory' to Hitachi, Toshiba, SDC and Microsoft's 2004 Software Factories — what worked, what failed, and why AI makes the generator cheap but leaves the organizational failure modes intact.

    50-60 min
  2. 02
    From DevSecOps Pipelines to Agentic Factories

    How the DoD's software factories, cATO and supply-chain security turned 'factory' into an attested pipeline — and how StrongDM, OpenAI and Anthropic redefined it in 2026 around agents.

    25-30 min
  3. 03
    What the Evidence Says — and a Factory Fit Audit

    METR, DORA and real incidents separated from vendor hype. Then audit your own work: which tasks belong on an unattended line and which never should.

    25-35 min
  4. 04
    Map the Line: Stations, Handoffs and Stop Conditions

    Design the factory before building it: intake, triage, build, verify, review and merge stations, their inputs/outputs, and the stop conditions that halt the line.

    30-40 min
  5. 05
    Make the Repo Legible to Agents

    CLAUDE.md as a map not a manual, structural tests, linters and fast feedback — the harness-engineering lessons that make unattended agents succeed on MeetingMemo.

    30-40 min
  6. 06
    Headless Claude Code: claude -p for Machines

    Run Claude Code without a human: claude -p, --bare, output formats, permission modes, tool allowlists, budgets and exit handling — the station worker's contract.

    35-45 min
  7. 07
    Build the Triage Station with Structured Output

    Turn GitHub issues into validated JSON work orders with --json-schema, Haiku-tier cost, and a replayable run you can inspect without spending tokens.

    35-45 min
  8. 08
    Hooks as Quality Gates

    PreToolUse denies, PostToolUse checks and Stop gates: enforce 'tests are read-only', 'never push main' and 'lint must pass' deterministically — not by asking nicely.

    40-50 min
  9. 09
    Docker Sandboxes for Unattended Agents

    Run the builder in a non-root, network-restricted Docker container with credentials kept outside the agent's reach. Includes Windows (WSL2 + Docker Desktop) setup.

    40-50 min
  10. 10
    Red-Team Your Factory: Prompt Injection

    Plant a malicious issue, watch what an unguarded agent does, then prove your hooks, sandbox and least-privilege tokens contain it.

    30-40 min
  11. 11
    The Verification Stack: Holdout Scenarios

    Unit tests, scenario tests the builder never sees, and LLM-judged satisfaction — StrongDM-style holdouts adapted to MeetingMemo.

    40-50 min
  12. 12
    Independent Verifiers and Reward Hacking

    Agents delete tests and special-case fixtures. Build a separate verifier with its own context and permissions, and detect test tampering automatically.

    30-40 min
  13. 13
    Orchestration Choices: Loops, Subagents, Workflows, SDK

    When a bash loop is enough, when to use subagents or dynamic workflows, and when to drop to the Agent SDK — with a decision table and costs.

    30-40 min
  14. 14
    The Builder–Verifier Loop with the Agent SDK

    Write a TypeScript or Python orchestrator that runs a builder, hands off to a verifier, retries with feedback, and stops on budget or round caps.

    45-60 min
  15. 15
    Worktrees, Retries and Escalation to Humans

    Parallel isolated runs with git worktrees, bounded retries, and clean escalation: when the factory gives up, it hands a human a useful draft and a diagnosis.

    35-45 min
  16. 16
    Trigger the Line from GitHub

    claude-code-action on issue labels, bot tokens so agent PRs trigger CI, timeouts, concurrency and subscription vs API-key authentication.

    40-50 min
  17. 17
    Scheduled and API Triggers

    Nightly sweeps and on-demand runs: scheduled cloud tasks, cron in Actions, and firing the factory from an API call — with guardrails on frequency and spend.

    30-40 min
  18. 18
    Self-Healing CI

    When CI fails on a factory PR, route the failure back to the line for a bounded fix attempt — and know when to stop.

    35-45 min
  19. 19
    Cost per Merged PR

    Instrument every run: total_cost_usd, tokens, retries and outcome. Model tiering, caching and budgets — and the one number that matters: cost per merged PR.

    30-40 min
  20. 20
    Kill Switches, Observability and DORA for Agents

    OpenTelemetry for Claude Code, per-producer DORA metrics, change-failure alarms and a one-command kill switch for the whole line.

    30-40 min
  21. 21
    Operate the Factory: Charter and Evals

    Write the operating charter (what the factory may and may not do), regression-test your prompts and skills with evals, and run a weekly factory review.

    30-40 min
  22. 22
    Capstone: Issue to Verified PR

    Assemble everything: a GitHub issue labeled 'factory' becomes a draft PR that passes hidden scenarios, stays under budget, and waits for a human merge.

    90-120 min

Included with the subscription

Software Factories with Claude Code isn't sold separately. The $45/month subscription includes it and every other course, plus everything we add next.

FAQ

Questions about this course

What do I need to install?

Docker is required for the sandbox labs. You also need Node 22, the GitHub CLI, jq and a private GitHub repo for the trigger labs. Windows works through WSL2 and Docker Desktop. You pick the Next.js or FastAPI track of the practice app.

What do the labs cost?

Measured lab runs cost $0.01 to $0.20 each. A Claude subscription or an API key both work. On a subscription, the reported cost is an API-equivalent figure and spend comes out of your plan quota.

How do I get access?

It is included with the subscription ($45/mo). It is not sold separately, and there is no one-time purchase.

What should I take first?

Claude Code Hidden Power, or equivalent knowledge. The course does not reteach CLAUDE.md, hooks or permission rules. It links back to those lessons (T602, T608, T610, T617) when you need them.