You’ve felt the FOMO. You’ve read the hype. You’ve watched competitors claim they are shipping 10x faster with AI, and now your board is asking why you aren’t running a ‘software factory’ with autonomous coding agents.
So, you wire up the tools, you set up an orchestrator, and you wait for the magic. But then July rolls around, the token bill hits, and you realize something terrifying: your output hasn’t actually improved. You’ve just turned your best engineers into exhausted chatbot controllers.
You didn’t eliminate the human bottleneck. You just moved it to a place where it costs ten times as much to fix.
The ‘software factory’ pattern is the most seductive lie in tech right now. It promises industrialized code generation, but it fundamentally misunderstands what software development actually is. A factory is built for repeatable production. Software development is a constant state of R&D and discovery. Confusing the two is a catastrophic misallocation of resources.
We are so obsessed with whether AI can write code that we ignored the real problem: defining what ‘done’ actually means. When you automate output without automating judgment, you don’t get a working system. You get a massive pile of unvalidated artifacts and janky cruft stored in your Notion workspace.
Just ask the teams currently in the ‘agentic orchestrator’ phase. They’ll tell you the bottleneck isn’t the model’s capability anymore. The bottleneck is acceptance testing. It’s UI verification. Mobile app testing still requires a human because AI models really suck at identifying visual regressions. You haven’t removed the need for human QA; you’ve just buried it under a mountain of AI-generated code that needs to be checked.
Automating code generation without automating evaluation doesn’t scale your engineering org. It just creates a very expensive layer of prompt orchestration.
This is the quiet dread every engineering leader is feeling right now: the FOMO of falling behind on AI adoption colliding with the reality of exhausted humans cleaning up after machines. The promise was that we’d remove human bottlenecks. The reality is that we merely shifted them into harder-to-delegate places: context sprawl, UI verification, and runaway token costs.
Adopting agentic systems is not a cost-removal decision. It is a cost-shifting decision. You are trading the cost of writing code for the cost of validating it, orchestrating it, and paying the API bills for it. If you don’t realize that, you’re going to burn your budget before you ever ship a working feature.
A factory stamping out parts you can’t verify isn’t a factory. It’s a liability.
If you want to win with AI, stop trying to build a software factory. Start redesigning your evaluation, governance, and acceptance testing. The teams that figure out how to automate judgment—not just code—will be the ones who survive. Everyone else will just be paying premium token prices to generate junk faster.
FAQ
Q: Are you saying AI coding agents are useless?
A: No, they are incredibly powerful for generating boilerplate and accelerating initial drafts. But they are useless if your testing and validation pipelines can't keep pace. AI is a multiplier for both productivity and chaos.
Q: What should engineering leaders do instead of building a 'factory'?
A: Invest heavily in automated acceptance testing and a strict definition of 'done'. If you can't automatically verify UI and edge cases, don't unleash autonomous agents on those parts of your codebase. You're just creating technical debt.
Q: What's the real problem with the 'software factory' metaphor?
A: It treats software like manufacturing when it's actually R&D. Factories thrive on predictability; software thrives on discovery. Trying to industrialize discovery just produces a lot of unvalidated, expensive garbage.