“I want agents to turn tickets into merged code while I'm away”

A software factory turns events, such as a new ticket, a pull request, a failed check or a clock, into coding-agent runs, and turns their output into merged code. Inside each run a harness drives a model through tool calls, the context window fills as it works, and its permissions are set in advance because nobody is watching. Each run works on a disposable runner and remembers nothing; the ticket tracker, the git host and the orchestrator hold the state between runs. The factory succeeds by giving agents a space where they can do the work and prove it: an agent-ready codebase with a short map, one verify command and a tool that drives the app, plus verification against scenarios the author never saw. Practitioners start with one throttled trigger and human review on every pull request, turn what review catches into checks, and let evidence earn trust. At level 4, low-risk work merges on checks and evidence, and people spend their review on specs, one-way doors and high-risk changes.

Product

Software factory

You might say: agent factory, autopilot, software kitchen, Michelin kitchen

A system that turns tickets, pull requests, failed checks and timers into coding-agent runs, and turns the runs' output into merged code. It works when agents have a space where they can do the work and prove it, so that human review leaves the critical path for low-risk changes.

Ask

What starts the work, what evidence proves it, and who may merge it?

What to look for

1. Tickets move to Done without a person starting each run
2. Bot-authored pull requests carry check results and the run's own evidence
3. Low-risk pull requests merge with no human approval
4. A run page records each ticket from trigger to finish

Parts

• Ticket tracker: A service that records work items and their state.
• Git host: A service that stores Git repositories and hosts their review objects, such as pull requests, checks and merge controls.
• Orchestrator: The service that receives trigger events, starts workflow runs, and records their lifecycle.
• Runner: The disposable machine or container that executes one run.
• Coding agent: A model harnessed with tools, a system prompt, and a context window, configured to carry one coding task through a run.
• Agent-ready codebase: The repository set up so an agent can find its way, make a change and prove the change works with no person watching.
• Task: A repeatable work definition that names its trigger, action, and next handoff.
• Verification: The evidence that a change does what its spec asked.
• Brakes: The gates that slow or stop a run before its change moves forward.
• Observability platform: The optional place where a factory records run status, logs, traces, token use and cost, and shows the factory's metrics.
• Factory design: The deliberate work of choosing a problem, adding triggers and services in small steps, and deciding where people stay in the loop.

Catalogue: Setup

• All on one git platform: The ticket board, pull requests, checks and workflow engine live in one hosted git platform. The shared platform joins the work item, the source change and its checks in one place.
• Dedicated tracker and own orchestrator: A separate tracker sends issue context to a team-owned service when an event fires. The tracker and dispatcher meet at an explicit event boundary.
• Own app for tickets and runs: A purpose-built application holds project context, work orders, agent connections, and feedback. The application is the durable interface for work context, work orders, and feedback.
• Vendor hosted agent platform: A vendor hosts the agent's ephemeral development environment while repository instructions shape its work. The platform supplies the run environment while repository instructions shape the task.

Pattern

Kitchen brigade

Sources

1. Simon Willison, How StrongDM’s AI team build serious software without even looking at the codeWe built a Software Factory: non-interactive development where specs + scenarios drive agents that write code, run harnesses, and converge without human review.
2. Factory, Software Factory documentation, Custom AutomationsEach automation starts a Droid session when its trigger fires: on a schedule, when a message lands in a Slack channel, on a GitHub event, or when another service sends a webhook.
3. Factory, Software Factory documentation, Events feedRuns Each run's outcome and duration, with a link to its session.
4. Factory, Software Factory documentation, Custom AutomationsAutomations turn Droid into a teammate for work that keeps coming back.
5. Matt Pocock, Software Factories for Real Engineers, Classic Concepts + Coding AgentsAssign your coding agent to chew through tickets, and come back to clean code and informative PRs for your review
6. Matt Pocock, software-factory skill (pull request #1316), Software factoryA software factory is a system of agents that turns tickets, PRs and schedules into merged code, deployed on remote infrastructure the user chooses.
7. Matt Pocock, AI Coding Dictionary, Software factoryA factory takes the human out of starting sessions, and not necessarily out of anything else.
8. Kent C. Dodds, kcd-skills, autopilot skillAudit any repository and set it up so coding agents ship changes safely with little human review.
9. Lauren Tan, pstack, pstackthroughput without quality is not a goal i aspire to.

Use it on your project

teardown-audit: audit my project against the "Software factory" teardown at https://teardownatlas.com/software-factory/

Paste it into a coding agent that has the teardown skills.

Every part

• Software factory
  • Ticket tracker
    • Ticket
    • Ticket source
    • Routing label
    • Comment thread
  • Git host
    • Pull request
    • Bot identity
    • Branch protection
    • Webhook
  • Orchestrator
    • Trigger
    • Run state
    • Concurrency limit
    • Work claim
    • Throttle
    • Try cap
    • Budget cap
    • Parallel runs
  • Runner
    • Disposable environment
    • Run timeout
    • Cache
    • Network egress
    • Secrets
    • Security boundary
      • Prompt injection
      • Least privilege
  • Coding agent
    • Agent harness
    • Model choice
    • Effort
    • Context window
    • Permission mode
  • Agent-ready codebase
    • Codebase health
    • Instructions
    • Shared vocabulary
    • Verify command
    • Control CLI
    • Tool access
    • Ratchet
  • Task
    • Run
    • Run chain
  • Verification
    • Spec
    • Scenario
    • Holdout scenario
    • Digital twin
    • Self-verification
    • Satisfaction
    • Non-determinism
  • Brakes
    • Automated checks
    • Automated review
    • Review and rework loop
    • Human review
    • Risk class
    • Merge policy
    • Review bottleneck
  • Observability platform
    • Run log
    • Agent trace
    • Token cost
    • Factory metrics
      • Merge rate
      • Lead time
      • Change failure rate
      • Review queue
  • Factory design
    • Start slow
    • Buy versus build
    • Autonomy level
    • Human re-entry
    • Slop
    • Human role
    • Factory evals
    • Trust loop
    • Improvement loop

• Accelerator with a brake
• Defense in depth
• Holdout set
• Kitchen brigade
• Ratchet
• Stateless worker with external memory
• Stop the line
• Two-way door

Flatpack

1. Pick the problem and the level
2. Fill the ticket tracker slot
3. Fill the git host slot
4. Draw the security boundary
5. Set up a disposable runner inside the boundary
6. Install the brakes
7. Configure the coding agent
8. Write the first task
9. Wire the orchestrator
10. Measure the factory
11. Watch the runs
12. Make the codebase agent-ready
13. Build verification
14. Merge by risk
15. Open the throttle and run in parallel

An AI agent wrote this map with the teardown skill. It can contain errors: check the sources before you rely on a part. About and legal