The end of one-shot engineering: Why your agents need a factory

In this conversation, Kerim Satirli maps the shift from one-shot AI prompting to the construction of personalized software factories. The core idea is that the industry is moving away from the illusion of deterministic AI toward a model where engineers treat agents as components of a rigorous, spec-driven pipeline. The implication is that the competitive advantage in the AI era will not go to those who generate the most code, but to those who build the most durable, opinionated constraints around that code. This is essential reading for infrastructure engineers and architects who feel overwhelmed by current agent noise and need a framework to regain control of their production environments.

The hidden cost of make no mistakes

Most engineers treat make no mistakes as a foundational prompt for their coding agents. Satirli argues this is not a strategy; it is a polite request that the system will ignore when the complexity of the task exceeds the agent context. When we rely on make no mistakes prompts, we are hoping for perfection rather than engineering for failure.

The systemic risk is that agents, trained on decades of human code, are prone to inheriting the same technical debt and logical fallacies we have spent years trying to excise.

> If we go into it with a mindset that our agent will make mistakes or our junior engineers will make mistakes then maybe we need to think about the hiring process differently. Why are we not helping folks that make mistakes whether they are human or agents to make less mistakes?
>
> -- Kerim Satirli

By shifting from one-shot prompting to a software factory model, which uses a series of automated, deterministic CI/CD harnesses, engineers can move from hoping for success to verifying it. This requires building custom jigs and constraints that force agents to operate within the specific architectural style of the organization.

The 18-month payoff: Why slowing down wins

The conventional wisdom is that agents exist to accelerate output. Satirli suggests the opposite: the most effective engineers are using agents to slow down their rollout processes. By automating the verification of infrastructure changes through spec-driven development, engineers can catch change drifts that would otherwise be ignored in a manual workflow.

This creates a competitive advantage that is invisible in the short term. While others are merging thousands of AI-generated pull requests without testing, the factory builder is investing time in building harnesses that block bad updates. Over months, this creates a massive divergence in system stability.

> I would rather work slowly than super fast because for me, yeah, I saw this blog post earlier actually this weekend when somebody was like in the last week I got 1,400 pull requests done and that is an amazing number. But what is the quality level?
>
> -- Kerim Satirli

The payoff is not just fewer outages; it is the ability to focus on high-level architecture rather than debugging one-shot errors at 3:00 AM.

The systemic response to AI noise

As AI-generated code floods open-source repositories, the system is responding by pushing back. Projects like cURL are increasingly wary of external, automated contributions. Satirli notes that the burden of maintenance has shifted; a pull request is no longer just a code change, it is a long-term commitment to maintain that logic.

The factory approach solves this by codifying the intent of the project. Instead of just a README, maintainers are moving toward hard, agent-accessible definitions of what constitutes a valid contribution. This forces the agent to read the architectural constraints of the system before it ever writes a line of code, effectively filtering out noise before it reaches the human maintainer.

Key action items

• Implement Bottom Line Up Front (BLUF) documentation: Stop burying intent in long-form READMEs. Over the next quarter, restructure documentation to be machine-readable so agents can verify architectural alignment before proposing changes.
• Build your own jigs: Stop relying on generic agent prompts. Over the next 12 to 18 months, invest in building a software factory, a set of custom CI/CD harnesses that enforce your team specific language and testing standards.
• Establish hard escape hatches: Identify high-risk resources like production databases or backup buckets and implement manual, human-in-the-loop verification gates that no agent can bypass. Do this immediately to prevent catastrophic automated deletions.
• Adopt spec-driven development: Shift your focus from coding to architecture. Before prompting an agent, draft a clear specification of the desired outcome. This pays off in 6 to 12 months by reducing the number of turns required to get a working implementation.
• Filter noise at the source: Configure your agentic workflows to ignore non-functional changes like code comments and only surface meaningful infrastructure deltas. This will improve your signal-to-noise ratio within the next month.
• Audit your one-shot dependencies: Review your current reliance on AI-generated code. If you cannot explain why a piece of code works, it is a liability. Over the next quarter, replace generic AI-generated snippets with code that adheres to your organization specific testing and quality standards.