How to build a software factory
And why they're the future of the SDLC
For the purposes of this article, agentic engineering is the process of iterating towards a software factory where the humans neither write nor read the production code. Agents decompose, code, verify and deploy - with no human involvement.
I’m on a lot of CTO lists and the responses to agentic engineering even in March of 2026 are still everything from “we’re tuning our automated software factory” to “it’s just auto-complete and will never ship robust production code”. AI denial is real, but it’s not useful.
There are lots of reasons to decide not to love AI writing the code:
It fundamentally changes role of software engineer - from crafting code to building guardrails, documenting requirements and verifications and sitting “on the loop” watching the output and improving the prompts, agents, skills, context and harness workflows incrementally to improve the quality and the efficiency of the system that is now building your software.
It takes a lot of energy - which has the potential to impact the climate for all of us.
It’s going to disrupt many organizations and have consequences for the labor market that are hard to foresee.
If you’ve ever tried to one shot something with a simple prompt and iterated in the context window until the model entered “the stupid zone” you probably wonder how anyone could even consider using this for brownfield apps or production code.
Compliance is an unsolved problem, but I know auditors are already in discussions with companies to extract the intent of the standards and to determine appropriate compensating controls.
But it’s coming. And if you haven’t yet had your “Claude code moment” personally, please put down the article, find a half day and play with it. Your job may depend on it.
Some recent examples of agentic engineering
In just the last few weeks, I noticed:
StrongDM got a lot of press for their software factory announcement. Three engineers, zero human-written code, 16,000 lines of Rust.
I think Steve Yegge is trolling the world with his Mad Max references, but Gas Town and Wasteland are amazing thought experiments and I know a lot of folks using his agentically generated beads to manage the backlog for their agents.
I’ve been following Sam Schillace since he presented at one of my CTO summits as SVP Eng at Box. He’s been working on software factories (they call them dev foundries) at Microsoft and yesterday he shared that this month he shipped almost a million lines of code - including a high fidelity clone of Word using web technologies.
Dan Shapiro coined the term “Dark Factories” - for “engines that turn specs into shipping software (Trycycle is one example).
OpenAI shared a great piece on harness engineering covering very similar ground. If you’re building a software factory, you should read it. Three engineers, 1,500 PRs, and one million lines of production code in five months.
How to build a software factory
The process is extremely simple. The optimizations can get pretty sophisticated.
Start by generating code
Document what’s wrong with the code, putting in place instructions that will stop that problem from recurring
When you have too many instructions in one agent (you’re blowing too much context on the rules) decompose into separate concerns - often a separate agent that will be called to review and provide feedback on the other agent’s code.
Repeat
When you get into the details, engineering taste and judgement are critical.
You’re going to need intermediate representations for things like business goals, specifications, architectural decisions and operational logistics.
You are going to need to capture all of the context, but then build systems to provide the right summaries of the right subsets of the context to the right agents at the right times.
You’re going to need to create deterministic pipelines and both syntactic and semantic validators to ensure the quality and alignment of both your intermediate representations and your final outputs.
You’re probably going to want to create and instrument human in the loop steps, capturing all of the human responses and using those to further improve the quality of the instructions, skills and agents that you use.
You may even want to implement a statistical, risk adjusted approach to quality with human reviews of PRs with the highest potential blast radius on the most critical code.
But, at its simplest; start, improve, split context/responsibilities, repeat.
What are you learning from building autonomous software factories in your org?