Inside a Software Factory: Where Agents Automate Delivery and Where Humans Still Decide
An O'Reilly-republished essay on Stack Overflow's blog describes a software factory: an eight-stage pipeline where coding agents handle triage, implementation, review, and release while people keep the planning and gating decisions.
TL;DR
- A software factory is an automated pipeline that turns raw work such as bug reports, feature ideas and incidents into shipped software, with a few human decisions at defined gates.
- The pipeline has eight stages grouped into what to build, building and checking, and self-improvement, all sitting on a shared context layer.
- The author argues that planning quality drives total cost more than model tier, and that humans remain central to brainstorming and planning.
From loops to factories
Much of the recent talk about AI-assisted coding has focused on labels such as prompt engineering, context engineering, harness engineering, loop engineering and graph engineering. The source, a republished essay from O'Reilly Media's Radar blog, shared on the Stack Overflow Blog, argues that the newer labels overexplain practices teams have used for years. It proposes the software factory as the more useful frame. Tereza Tížková of Factory.ai defined one at AI Engineer World's Fair 2026 as "the whole loop, the whole lifecycle of developing software with autonomy."
The author describes a factory as a system where raw work goes in and shipped software comes out, with minimal human input. Humans make a few high-leverage decisions and set gates that work cannot pass without them.
The eight stages
The essay groups the stages into three buckets. In the first, what to build, triage classifies and deduplicates incoming work, brainstorming looks for high-impact features, and planning turns research into tickets. Planning records decisions in an ADR (Architecture Decision Record), a short document of a design choice and its reasons, plus a glossary.
The second bucket covers building and checking. An implementing loop pairs a software engineer agent with a QA agent. Review checks the pull request against product, architecture and code standards. Review-CI runs the test suite and sends failures to a fixing agent. Release handles deployment to staging and production, with human checks before go-live.
The third bucket is self-improvement. Monitoring feeds alerts, errors and incidents back into triage as new input, which closes the loop.
The context layer
Across all stages sits a context layer, the documents, data and knowledge a model can read. The author stresses its importance early in the pipeline. Brainstorming only sees the data it is given, and a thin context layer narrows the options. The essay cites Andrej Karpathy's term "LLM Wiki" for a knowledge base built from plain files rather than a database. Factory's AutoWiki feature and LangChain's OpenWiki CLI are mentioned as examples of this approach.
Where the human stays
The worked example in the essay is a shopping assistant on an ecommerce platform, where users do not engage with recommendations. Agents gather usage data and competitor research. A team member then judges the problem and writes a feature spec that describes the business problem, not the technical fix. In planning, the human checks feasibility and architecture, while the agent scans the codebase and questions the plan.
The author also argues about model choice. Planning burns fewer tokens than implementation but shapes everything after it. A well-written plan lets cheaper models execute. The essay reports that Sonnet on high reasoning could cost more than Opus on the same task when the plan was weak, because more retries mean more tokens. Total cost is tokens multiplied by price, so failed attempts raise the bill.
For the implementation loop, the essay advises giving the QA agent one command that starts the full stack, and layering feedback from linting, unit, integration and end-to-end tests. It also warns that a model grading its own work tends to be too lenient, so separating the two agent roles matters.
Why it matters
For developers and teams, the practical lesson is that the quality of specs, ADRs, tickets and context documents determines how well agents perform. Investment in test infrastructure and a reproducible local environment becomes a prerequisite, not an extra. Teams should decide where human approval is mandatory, such as before release, and measure cost per completed task rather than per token. The essay is an opinion piece from one practitioner, so its cost comparisons come from his own experience and not from a controlled benchmark.
Sources
This article was written by Blozhik from the reporting below. Read the originals for full detail.
StDispatches from O'Reilly: Inside a software factoryStack Overflow Blog