What is a software factory?
What we’ll cover
What a software factory is, and the crawl, walk, run path this course follows: automations first, then the inner factory loop, then the outer loop that improves the factory itself.
Now that we've learned what you'll do as a factory engineer, let's talk about the infrastructure you'll use to deploy and optimize your system of agents: a software factory.
A software factory is an automation loop that orchestrates agents to build software better and better over time. In its ideal form: you set the product requirements, and the factory builds and optimizes your product without any human interaction.
Of course, agents aren't at the level (yet) to take “build product and make money” as an input and run forever. That's what factory engineers are for: to build a factory that automates as much of the software development process as possible, tuned with cost and quality in mind.
To do this, the factory engineer will need to own:
- The cost for each unit of work flowing through the factory.
- The quality of code that the system outputs.
- The security permissions (secrets, skills, and MCPs) that every agent has access to.
This means tracking not just your local agent setup, but everyone's agent setup across your team. That's why software factories are centralized: always-on, in the cloud, and fully owned by the team as code.
You'll be using Warp Factories to build your own software factory, which provides the configuration format, compute, inference, and a dashboard to measure and improve cost and quality. If you're curious, there are options to self-host everything as well.
The software factory loop
Let's see what we're building. In the next unit, we're going to program this inner factory loop:
Prompt
Every task starts from a trigger: a chat message, a Slack mention, a GitHub comment, a Linear ticket, or wherever else. We'll set up the automations that turn these into factory tasks, with any links, logs, and screenshots attached.
We'll dive into where agent automations fit into each step of this chain. For now, just focus on the high-level ideas:
- Agents run in an automatic loop by listening to external triggers (Slack messages, taskboard items, error monitor pings, etc).
- Humans get involved (hey there "product engineering") where our judgement is most valuable. That's aligning on features, reviewing mission-critical code, and giving feedback on the product.
Once our factory is running, we'll set up agents that watch over and improve the factory itself (the outer factory loop). We'll cover three core components to this:
- Scoring: Define rubrics of metrics we care about (say, code quality, number of redundant tests, efficiency of the agent's tool calls), and have agents “score” tasks in our factory based on those rubrics. These become your measurement for how your factory is performing.
- Self-improvement: Find tasks that “score” especially poorly, and allow an agent to suggest changes to the code or agent skills driving your factory to prevent those failures in the future. It's a bit like recursive self improvement, but you don't have to be a frontier lab to implement it.
- Benchmarking: Sample tasks that have run through the factory before, and “replay” those tasks while swapping out different factory configurations. Then, score the outcomes, compare results, and deploy the winner.
Ready to build? Let's get started.