How to Build Your Own Software Factory

The Engineer Becomes a Director

The core idea of the lecture is that software engineering's bottleneck has shifted. Tools like Claude Code, Codex, and Replit Agents can generate code for hours without supervision, making code generation less important than planning, testing, deployment, and verification.

The modern engineer acts less like a coder and more like a director, managing AI agents that execute work. A software factory makes this possible by taking a specification and turning it into a deployed application with minimal human involvement. The technology is still early, however. Factories can automate much of the work, but human engineers are still required to review outputs, resolve edge cases, and push projects from 80% complete to production-ready.

The 11 Building Blocks of a Software Factory

A software factory is less about any single tool and more about how the components work together.

The key building blocks are:

1. Record System – Tracks work and ownership (e.g. Linear).
2. Memory – Persistent project context stored in files.
3. Orchestrator – Coordinates agents and workflows (e.g. LangGraph).
4. Execution Environment – Sandboxed environments where agents operate.
5. Agent Runtime – The coding agents themselves (Claude Code, Codex, etc.).
6. Integration Layer – Connections to tools like GitHub, Vercel, Supabase, and Slack.
7. Quality Gates – Human review checkpoints.
8. Delivery Target – Where applications are deployed.
9. Observability – Tracing and monitoring agent behavior.
10. Skills – Reusable domain knowledge and workflows.
11. Identity & Secrets – API keys, credentials, and access control.

The specific tools may change over time. The architecture remains largely the same.

How the Factory Works

The process begins with a ticket in a project management system such as Linear.

A webhook triggers project setup, creating the repository, deployment environment, database, and project memory. A product-management agent writes the initial specification, which is reviewed by a human. An architecture agent then produces the system design and implementation plan, followed by another review checkpoint.

The orchestrator breaks the project into parallel tasks and assigns each one to an isolated coding agent. As work progresses, agents contribute to a shared pull request while automated review and testing agents validate the output.

Once final human approval is given, the code merges and deploys.

Memory and Agent Coordination

Agents do not share memory by default. Each starts with minimal context and must rely on documentation, files, and generated artifacts to understand the project.

Ash argues that file-based memory is often more reliable than graph-based memory because it is easier to maintain and less prone to drift. The same philosophy underlies Anthropic's Skills system: persistent knowledge stored in files and revealed when needed.

Three principles make memory effective:

• Never overwrite history; append instead.
• Read relevant context before writing code.
• Avoid multiple agents editing the same memory simultaneously.

Agent coordination remains one of the hardest problems in multi-agent systems. A practical solution is assigning ownership of specific files and enforcing file locks to prevent conflicts.

Orchestration, Cost, and Governance

The orchestrator acts as the factory manager. It maintains state, launches agents, handles retries, and resumes work after interruptions without restarting the entire workflow.

Cost can be managed by pairing models strategically. A common pattern is to have a lower-cost model generate code while a more capable model reviews it. This dramatically reduces spend while maintaining quality.

Governance starts with visibility. Every agent action should be traceable through observability tools. Once visibility exists, teams can add evaluations and scoring systems to measure agent performance and continuously improve the factory.

The overall takeaway is that successful software factories are not built from dozens of specialized agents. They are built from a small number of reusable agents, clear workflows, strong memory systems, and well-designed human review checkpoints.