Software Factory

The Software Factory workflow is: after creating an issue on GitHub and tagging it with the 'ready' label, the factory automatically dispatches the task to an idle Agent, which upon completion submits a Pull Request for human review.

In traditional software engineering, a software factory refers to a standardized, reusable set of development processes and toolchains, with the goal of making software production as efficient and predictable as a factory assembly line.

A consensus is forming in the AI coding world: the core of a software factory is not "more Agents" but "higher trust".

Agents will plant bad seeds in the environment, then keep producing garbage, ultimately causing the factory itself to shut down.

Because all tasks go through exactly the same sequence of steps, after changing models or adjusting prompts, data can be accumulated to compare cycle time and task completion rates, constituting a low-cost controlled experiment.

The improvement path the author suggests is: first establish observable run records, then use data to drive process improvement, and finally lock validated changes into the process.

A software factory is a set of underlying infrastructure that lets coding agents run according to a defined process, recording all metrics and data on every run.

Design work and tasks requiring repeated iterative exploration are not suitable for the software factory, and the author still uses coding agents locally for such work; local agents and the software factory are complementary rather than a replacement.

In 1968, Bob Beamer of GE proposed the original concept of the software factory.

The automated loop of a modern Agent software factory is: feature request → spec Agent writes the spec → build Agent writes the code → security/UX/UI/quality and other sub-Agents review independently → if any item fails, return to the build Agent → after all pass, escalate to humans for merge approval.

An Agent's ability to identify useful tasks does not grant it the power to allocate the permissions needed for those tasks.

At the very end of the entire pipeline, a human decides whether to ultimately merge, with AI responsible for production and initial screening while humans retain final decision-making authority.

A Software Factory is an engineered collaborative system built around AI coding agents, whose core is the coordination mechanism rather than the agents themselves.

The fundamental cause of parallel agent failure lies in the coordination problem: without task division and isolation, agents compete for the same task and overwrite each other's changes, producing conflicting code that cannot be merged.

After an agent claims completion, the Software Factory re-runs tests and has a dedicated reviewer agent inspect the code diff to catch issues that test coverage cannot detect.

The Software Factory built by the original author targeted 10 real GitHub issues, of which 9 produced PRs through the pipeline, but 7 of those still failed in unexpected ways in actual use.

What determines output quality is often not the capability of an individual agent, but whether the surrounding coordination, isolation, and verification systems are well-designed.

The orchestration capability for parallel agents is no longer difficult to implement; the challenge lies in guaranteeing output quality.

Multiple agents working in the same local checkout directory causes stacked change conflicts; the solution is for each agent to use an isolated sandbox with its own code copy and machine.

The essence of a software factory is an operating loop: issues enter a to-do queue, a coding agent picks one up and writes a fix, an independent system verifies the work, and finally a human decides whether to merge.