How to Build a Reliable AI Software Factory

TL;DR

A reliable software factory uses four steps: isolate, build, prove, and ship. Each feature begins in a separate Git worktree, follows explicit code-structure instructions, produces evidence such as screenshots or measurements, and passes pull-request review before merging. Because the workflow lives in a small collection of Markdown files, it can operate with different AI models and agent harnesses.

Transcript

What are software factories and why is it going viral? I mean, it's basically this concept that allows you to use AI agents to actually ship software that isn't sloppy at all that is more like a factory, more like think about an assembly line and you're just instead of building physical products, you're building software. And that's kind of the dre... Read More

Key Insights

• A software factory is a repeatable workflow of skills and domain knowledge that helps AI agents produce valuable software quickly without sacrificing quality. It resembles an assembly line because each feature moves through defined stages instead of relying on an unstructured conversation with an agent.
• The workflow is model-agnostic and harness-agnostic, meaning its underlying process is not tied to a particular AI model or coding product. The same factory principles can therefore be applied while using tools such as Codex, Claude Code, Cursor, or another compatible agent environment.
• An AGENTS.md file is a persistent instruction document that is included whenever the developer communicates with an agent. Its most useful content describes workflows the agent cannot infer directly from the repository, rather than repeating facts that the agent can already discover by reading the codebase.
• The isolate stage is the first step of the factory and requires every feature to begin in a fresh Git worktree branched from origin main. This gives each agent a separate copy of the project and keeps concurrent feature work from interfering with other active tasks.
• Git worktrees enable several agents to develop separate features at the same time without sharing one working branch. When an agent finishes, its changes can be merged into the main project, allowing parallel work while reducing accidental deletion, replacement, or modification of another agent’s code.
• The build stage uses a code-structure skill to guide how the agent implements a feature. In the demonstrated factory, these instructions direct the agent to write service-layer code that a human developer can understand instead of accepting whatever structure an unguided generation happens to produce.
• The prove stage requires evidence that a change works, including a recorded before state and after state. Depending on the feature, that evidence can take the form of video, screenshots, or numerical results, making validation more concrete than an agent’s unsupported claim that implementation is complete.
• The ship stage reviews the pull request through a grep loop and Greptile before integration. Greptile scores the pull request, adding a defined review checkpoint to a process that begins with isolated implementation and continues through structured building and evidence-driven testing.

Questions & Answers

Q: What is an AI software factory?

An AI software factory is a structured workflow for using agents to build and ship software with speed and consistent quality. It packages development skills, domain knowledge, and operating rules into reusable instructions. The demonstrated system moves each feature through four stages: isolate, build, prove, and ship. It is designed to work with different AI models and agent harnesses rather than depending on one product.

Q: Why does a software factory use Git worktrees?

A software factory uses Git worktrees to give every feature and agent an isolated copy of the application. Each feature begins in a fresh worktree branched from origin main, so agents can work concurrently without changing the same files on one shared branch. Once a feature is complete, its changes can be merged back into the main project in a controlled way.

Q: How can multiple AI agents build features in parallel?

Multiple AI agents can build features in parallel by assigning each feature its own branch and Git worktree. One agent might update a landing page while another improves API calls, and additional agents can address other features in separate copies. This arrangement prevents agents from directly overstepping one another during implementation, after which completed work can be merged into the main branch.

Q: What should an AGENTS.md file contain?

An AGENTS.md file should contain workflow instructions that are not already obvious from the repository. In the demonstrated setup, it tells agents how features progress through the factory, beginning with isolation in a fresh Git worktree. Repeating the codebase’s existing structure is less useful because an agent can inspect that information directly, while custom operating procedures must be stated explicitly.

Q: What are the four stages of a software factory?

The four stages are isolate, build, prove, and ship. Isolate creates a fresh Git worktree for the feature. Build applies a code-structure skill that guides implementation toward readable service-layer code. Prove records before-and-after evidence using video, screenshots, or numbers. Ship reviews the pull request through a grep loop and Greptile before the work is integrated.

Q: How does the build stage improve AI-generated code?

The build stage improves AI-generated code by giving the agent an explicit code-structure skill. In the presented factory, that skill directs the agent to produce service-layer code that a human developer can read. This replaces an entirely open-ended generation process with documented implementation expectations, helping the model apply the creator’s preferred development structure each time it builds a feature.

Q: How do AI agents prove that a software change works?

AI agents prove a software change works by recording evidence from before and after the implementation. The evidence may be a video, screenshots, or numerical results, depending on the type of feature. This evidence-driven testing step creates a visible or measurable basis for judging the result, rather than treating the agent’s statement that the work is finished as sufficient proof.

Q: Can a software factory work with different AI coding tools?

A software factory can work with different AI coding tools because its core is a workflow, not a specific model or harness. The described setup stores its process in five or six Markdown files containing skills and operating instructions. The same ideas can be used with Codex, Claude Code, Cursor, or another agent environment that can follow those repository-level instructions.

Summary & Key Takeaways

• A software factory is a structured development workflow that packages skills, domain knowledge, and operating instructions into five or six Markdown files. Its purpose is to maximize an AI model’s capabilities while preserving speed and quality. The approach is model-agnostic and harness-agnostic, so it does not depend on one provider or product.

• The isolate stage starts every feature in a fresh Git worktree branched from origin main. Each worktree acts as a separate copy of the application, allowing multiple agents to develop different features concurrently. Finished changes are merged back into the main branch, reducing the risk that one agent overwrites another agent’s work.

• The remaining stages are build, prove, and ship. A code-structure skill guides agents toward readable service-layer code. The proof stage records before-and-after evidence through videos, screenshots, or numbers. During shipping, a review loop and Greptile evaluate the pull request before its changes become part of the main application.