— named one of yc demo day's standout startups —

— named one of yc demo day's standout startups —

All posts

How to build a software factory, one station at a time

The stations every change passes through, how to hand each one to agents, how to judge the handover, and why the bottleneck moves to deciding what to build.

Ben Ong

November 22, 2026

ai-agents

SDLC

A lightbulb leading into a line of six halftone stations and an open door on an orange paper background

A lightbulb leading into a line of six halftone stations and an open door on an orange paper background

TL;DR: A software factory is the line a change travels from idea to production, with agents doing the work at each station and people setting the rules. You don't build it in one go. You hand one station at a time to agents, starting with the longest queue, and you decide how you'll judge each handover before you look at the results. Once delivery runs on its own, the slow part becomes deciding what to build, so the people who make that call need a direct way in.

Agents now write a growing share of most teams' code. The first thing that happens is that the queue moves. Code gets written in minutes, then waits hours for CI fixes, review, approval and testing, and every one of those handoffs still lands on an engineer.

The more code agents write, the more handoff work engineers inherit. Asking agents for better code doesn't fix that. Handing them the handoffs does.

Here's how we think about building a software factory, one station at a time.

The stations between an idea and production

Every change passes through the same stations, whether a person or an agent does the work:

  1. Decide what to build
  2. Write the change
  3. Pass CI
  4. Review: read the change and ask for fixes
  5. Approve: the sign-off that lets it merge
  6. QA: test the product like a user
  7. Fix breaks on main
  8. Run the line: decide what each agent works on, and in what order

In most teams today, agents help with step two and engineers carry the change through everything else. A software factory moves each station to agents, with clear rules for when a person steps in.

Station 1: decide what to build

The problem. This station gets skipped because it doesn't look like engineering. A change arrives as a one-line ticket, and the agent fills every gap with a guess. The code can pass every later station and still solve the wrong problem.

What to build. A shared, codebase-aware plan before any code exists. It covers the problem, the intended behavior, what must not change and how the team will know it worked. The people closest to the problem write it: PMs, designers, ops and support.

How to know it works. Count how often a finished change goes back because it wasn't what anyone meant. That number should fall.

The lesson. Every station after this one depends on the plan. It's the context the coding agent builds from, the reviewer checks against and QA tests against. We've written about why the review bottleneck is really an alignment bottleneck.

Station 2: let agents get to green

The problem. An agent that stops at "code written" saves an hour of typing, then leaves an afternoon of cleanup: failing tests, lint errors, merge conflicts and review comments.

What to build. Agents that run in the cloud and own a change until it's green. They write the change, open the pull request, rerun CI, fix tests, answer review comments and rebase, without anyone keeping a laptop open.

How to know it works. Track the share of merged pull requests where no person had to push a commit.

The lesson. Agents need somewhere to run that isn't an engineer's machine. That's the case for cloud agents.

Station 3: let agents review

The problem. Review bots without context leave generic comments, so engineers learn to skim past them and read every change themselves.

What to build. An AI reviewer with the same context as the agent that wrote the code: the plan, the diff and the code around it. The change goes back and forth between the coding agent and the reviewer until it's clean, before a person ever sees it.

How to know it works. Measure how many of the reviewer's comments get resolved or lead to a code change. If engineers ignore them, the reviewer is missing context.

The lesson. A reviewer, human or AI, can only say whether a change is right if someone agreed on what right means. That's station one again.

Station 4: decide who approves what

The problem. Clean changes still wait hours for someone to click approve. Removing people from approval entirely isn't the answer either.

What to build. An approval policy written down by risk. One way to set it up:

Change Who approves
Low risk, like copy or styling A lighter check, set by the team
Medium risk A reviewer, within limits each repository sets
High risk An engineer, after a deeper check
Critical paths A code owner, always: database migrations, CI and deploy config, secrets and authentication

How to know it works. Track how long changes wait for a first approval and how often approved changes get reverted.

The lesson. Approval is a policy decision before it's an automation. Any new approver, human or agent, should run alongside your current reviewers first so you can see where they'd disagree.

Station 5: let agents run QA

The problem. Passing tests and working software aren't the same thing. Someone still clicks through the product by hand before a change ships.

What to build. Agents that use the product like a person would, on a preview of the change. When they find a bug, they confirm it isn't their own setup, find the code that caused it and hand a fix back to a coding agent. Then they rerun the scenario to check the fix.

How to know it works. Count the bugs caught on previews compared with bugs found after release.

The lesson. Check the work while it's built, not only at the end. It's why we verify every step instead of only the final pull request.

Station 6: let agents watch main

The problem. More merges mean more chances to break main. Every hour main stays broken, more changes pile on top of the break.

What to build. A response that starts when an alert fires: retry the checks, diagnose the failure, apply a known fix if one exists and call a person if none of that works. After each release, a health check that rolls back on failure.

How to know it works. Track the time from a red build to green, and how often a person gets paged.

The lesson. Your incident runbooks are agent playbooks waiting to happen. Write down the fixes you already know, and decide in advance when a person gets called.

Station 7: let agents run the line

The problem. Once every station has an agent, engineers become the coordinators. They start agents, order merges and babysit runs that stall.

What to build. One coordinating agent that reads the backlog, hands work to agents and orders merges. It brings in a person when your rules require one or when a step gets stuck. This is the top of the five levels of running coding agents.

How to know it works. Run it read-only first, so it only records what it would do, and have a person check its decisions before it acts on any of them.

The lesson. A coordinator needs safety rails:

  • Read-only shadow mode before any writes
  • Checks re-run on the exact commit being merged
  • Actions that are safe to repeat if a run retries
  • People step in by policy, not by accident
  • Rollback in one step

What engineers do in a software factory

Engineers read a smaller share of the diffs. Their job moves to the road between the stations:

  • Set the rules for what ships, including who approves which changes.
  • Answer agents' architecture questions before a wrong assumption spreads through a change.
  • Find where agents stall, such as areas of the codebase where changes keep needing rework.
  • Fix the road. Most fixes are a cleanup, a written convention agents can read, or a test that stops a bug from coming back.

The factory gets faster when engineers fix the places agents struggle, not when they read more code.

The bottleneck moves upstream

Automate delivery and the wait doesn't disappear. It moves to station one, deciding what to build.

That work mostly isn't engineering work. A PM knows which customer problem is worth solving. A designer knows the states and edge cases a user will hit. Ops and support know where today's workflow breaks. When the factory runs fast, each of those decisions is worth more, and a vague ticket costs more.

That's why we think the software factory needs to become a product factory, with product people working inside it instead of filing requests at the edge.

Where LightSprint fits

LightSprint is a software factory for the whole product team, built on your real codebase:

  • Start where work already happens. PMs, designers and ops describe a change in plain language, or start it from Slack, Linear or Jira.
  • Agree on the plan first. The team shapes a plan grounded in the real codebase in one shared session, so every later station has the context it needs.
  • Build in the cloud. Agents work through the plan task by task, each in an isolated sandbox with the app running. Nothing runs on anyone's laptop.
  • Verify as it's built. Each step is checked with screenshots of what changed, and the finished change gets a QA pass with a recording.
  • Keep engineers in charge of what ships. Builders propose changes and view previews but can't merge. Approvers, usually engineers or leads, review and merge through the GitHub rules, required reviews and CI the team already uses.

See how it fits your engineering workflow.

How to start building your own

  1. Find the longest queue. For most teams it's review or approval. Start there, not with the most impressive automation.
  2. Decide how you'll judge it first. Pick the measure, such as wait time, reverts or how often people disagree, before you see results.
  3. Run it in shadow mode. Let the new station make decisions without acting on them, and compare against people.
  4. Write the approval policy by risk. Keep code owners on migrations, secrets, authentication and deploy config.
  5. Fix where agents stall. Track friction and fix it with cleanup, documentation or a guardrail test.
  6. Bring product people into the plan. The faster the line runs, the more each decision about what to build is worth.

FAQ

What is a software factory?

A software factory is a system where coding agents take a described change through writing, testing, review and release, with people setting the rules and stepping in where judgment is needed. Read our guide to what a software factory is.

Where should I start building a software factory?

Start with the station where changes wait the longest, usually review or approval. Decide how you'll measure the handover before you start, and run the new step alongside people before it counts.

Can AI approve pull requests in a software factory?

Some teams let AI approve low-risk changes and keep people on high-risk ones. Whatever you choose, write the policy down by risk, keep code owners on critical paths like migrations, secrets and authentication, and test any new approver in shadow mode first.

Where does the bottleneck go once delivery is automated?

Upstream, to deciding what to build and answering agents' questions. That work usually sits with PMs, designers and ops, which is why they need a direct way into the factory.

Do engineers still review code in a software factory?

Yes, but they read a smaller share of diffs and spend more time on rules, architecture and the places agents stall. In LightSprint, an engineer approves every merge back to main through your existing GitHub rules and CI.

Start for free