Overcoming challenges in software factory adoption

Setting up a software factory is technically challenging – those who claim otherwise aren’t actually doing it for real. But the bigger challenge might ultimately be helping developers get excited to use software factories.
I’m going to discuss two distinct issues:
- The misconception that adopting software factories means you are no longer doing interesting engineering
- The issue that in a software factory paradigm, individual developers must embrace working with agents in public at the team level, rather than locally in private
For (1), the problem starts with the term “software factory” itself. It conjures a mechanized, non-creative process of putting work through an assembly line. You imagine the output being a set of identical commodity products (e.g. cars coming off the line).
Working on an assembly line isn’t what I signed up for as a developer, and if that’s the vision that we are presenting to development teams, naturally they are not going to get excited.
So I propose a different vision: the job of an engineer going forward is not working on the line – it’s designing the factory. You aren’t suiting up in a blue jumpsuit every day to push slop out the door; you’re trying to engineer a state of the art Tesla factory, but for useful software.
And, this factory does not just produce one kind of thing. It’s a factory that produces bespoke, useful software for your customers. The only reason the “factory” term is apt at all as a metaphor is that if you are building a Tesla factory, you better care a lot about optimizing throughput while minimizing cost and maintaining quality. This is the factory mindset.
The second issue I see when we work with companies to deploy software factories is the shift from an individual devtools mindset to a team factory mindset.
Developers have always set up their own local “cockpit” of devtools. This could be everything from choice of terminal (e.g. Warp or Ghostty), whether you use an IDE or emacs/vim, down to minute details around your keybinds, visual theme, etc. In an agent world, the equivalent is every developer picking their own harness, model, skills, MCPs, etc. This is part of the fun of being a developer: you’ve always gotten to “engineer” your own personal productivity.
In the devtools paradigm, the first moment that work goes from being private to public is when a developer opens a PR. Until then, you, the developer, iterate locally, in private, using your own special sauce to produce code that will eventually get reviewed by a peer, pushed through CI, then out to the world.
In a software factory world this changes; by default you work in public, and this is good. The idea that every developer is going to have their own unique way of managing coding agents (their skills, mcps, workflows, and so on) does not scale.
Your VP Eng, CFO or CISO might not have cared if you were using emacs or vim, but they certainly care if you are using Fable or GLM to spend millions of dollars in tokens. They care if you are using insecure skills that might give a prompt-injected agent the ability to act as you and access sensitive systems. They care if there are engineers on the team who are 100x more productive than others.
The very obvious solution is to remove some amount of developer choice and variance from how software is built by agents. This is what software factories do, and I believe it’s a necessary and ultimately positive change. They move the agent system off of the individual’s laptop into cloud infrastructure, where all the agent behaviors are owned by the team, defined in code, and engineered over time to get collective - rather than individual - improvement.
The flip side is that when you move agent control to the team and organization level, you remove some autonomy from developers. You also force them to work in public in a way that may be uncomfortable. For engineering leaders rolling out software factories, this is where you may face the biggest hurdles in adoption. You may find that engineers, especially more senior ones, will rightfully say “my personal productivity depends on my local setup and if that setup moves to centrally managed infrastructure I can’t get as much done”.
For some of your engineers this may be true for now, but bespoke individual setups are not the answer in the long term. My advice is to acknowledge that there can be some friction in making the transition, and for some engineers who have optimized their local setups it might feel like a temporary step backwards. But you then must paint the vision that in the end state, agentic coding systems belong to the team and organization, and are best not managed a hundred different ways by each and every individual.
Cast this as an engineering problem to solve together as a team: how do you collectively set up the best shared infrastructure so that everyone can benefit and improve it together? This is factory engineering and it’s inherently a team endeavor, not a solo one.
Ultimately as an engineering leader or platform team you might need to take a firm stand that the future is shared agent infrastructure, not custom individual agent setups. I believe this deeply and feel like it’s pretty obvious if you step back and think about it. The future of coding agents is not a million individual bespoke ways of using them to push PRs into CI. It’s a fully encoded system for using them to build software together, in the cloud, with well defined guardrails, and collective measurement and improvement over time.
This is what software factories enable, and if you believe the vision you should be prepared to encourage change to get there. It’s similar to a year ago when some developers still claimed they could be more productive writing code by hand and had yet to switch to agentic coding.
The same shift is going to happen here, and the most successful companies are going to embrace it now and get their factory infra humming today.
Start your software factory
Book a demo and we’ll walk you through the workflows that map to your stack.
Related articles
Nov 5, 2026Engineering
9 min
Addressing the code review bottleneck
9 min
Nov 4, 2026Engineering
11 min
Don’t vibe code your software factory
11 min
Oct 29, 2026Engineering
9 min
7 core components for building a software factory
9 min
Oct 15, 2026Engineering
10 min
Tactics for rolling out software factories: human and organizational changes
10 min
Oct 15, 2026Engineering
7 min
The road to self-improving software
7 min