Build the Software Factory: Rules and Harnesses for Coding Agents
Coding stopped being the slow step. The next useful move is to stop treating agents as chatty one-shot coders and start building a software factory: coordinated, repeatable agent loops with clear triggers, scaffolds, deterministic checks, and human ownership of architecture and judgment.
This is the practical pattern emerging from the latest talks on Beyond Coding and from David Ondrej. It is a different emphasis from pure bottleneck analysis. The bottleneck has already moved to review, trust, and verification; the question now is how to structure the factory so agents stay useful on production systems without degrading the codebase.
What a software factory actually is
David Ondrej frames it as a collection of agent loops rather than more manual prompting. Each loop has:
- a trigger (schedule, webhook, product event, error, customer feedback),
- a bounded task with the right model, skills, context, and tools,
- some form of checking or follow-up.
A factory is many such loops across product work, security, database health, billing, or support. Humans stay responsible for prioritization, taste, strategy, and high-risk approvals. The operator is no longer the bottleneck that starts every session by hand.
See: Stop coding, build Software Factories instead (and related discussions of moving from manual prompts to loops).
Concrete rules from senior practitioners
Scaffold first; keep the main agent off the files
Carlos Kelkboom (lead architect, Beyond Coding) is explicit: agents are bad at iterative changes and good at one-shot execution. His practice is to manually create the directories, key files, function or type signatures, comments, and folder boundaries before any implementation agent runs. His primary conversational agent stays in an “open” mode—it discusses, teaches, and builds mutual understanding—but never touches files. Only when confidence is high does it launch a closed worker for a narrow or large one-shot task.
He uses a graph-style harness (Markdown nodes, progressive disclosure via links, commit hashes, short summaries) so context is retrieved on demand instead of dumped into every prompt. Parallel experiments run in git worktrees; the best implementations are merged and the rest discarded.
Most important rule: throw the code away if you do not understand it, even when it passes tests. Understanding is what lets you maintain, debug, and extend it later.
Full episode: Lead Architect Reveals His Rules for Coding Agents.
Turn agents into fancy, deterministic CI/CD
Kerim Satirli (HashiCorp / IBM) makes the same shift on production infrastructure. “Make no mistakes” is only a polite request; it is not a hard line. He steps away from pure non-determinism and treats agents more like an enhanced CI/CD pipeline: run quality tools, evaluate plans, surface unexpected diffs (for example a Terraform provider that keeps showing changes), cross-check against known issues via search, and recommend holds.
Most Terraform applies can run automatically so the human is not the perpetual blocker; risky changes keep escape hatches. Specs (GitHub Spec Kit style), BLUF (bottom-line-up-front) summaries that cut documentation noise, and personalized factory constraints replace hope. Almost every engineer he knows is already building or heavily customizing their own factory.
Full episode: How Senior Engineers Use Coding Agents On Prod Infrastructure.
What to do on Monday
- Pick one repetitive, clearly bounded loop (provider updates, security scanning of your own repos, feedback triage) and give it a real trigger plus an independent check.
- Scaffold the structure and the definition of done yourself. Keep the coordinating agent read-only until the task is clear.
- Prefer one-shot or large bounded tasks over endless iterative patching. Isolate work in worktrees.
- Encode safety and anti-slop as hard gates (hooks that refuse edits, quality tools, short-lived credentials, plan evaluators) rather than prompt wishes.
- Share the factory interface—specs, skills, evals, the context graph—so the whole team can use the same loops.
The teams that stay fast are not the ones running the most unattended agents overnight. They are the ones who noticed the bottleneck moved and then built the harnesses, scaffolds, and verification loops that let agents keep producing without making the codebase worse.
Sources: the two recent Beyond Coding episodes linked above, plus David Ondrej’s software-factory framing. Related discussion on Hacker News continues to highlight review load and CI pressure under higher agent volume, reinforcing why the factory needs deterministic checks rather than more generation.