Software Factories Are Dead. I'm Building a Team of Bots.
My first day with Devin Bots raised a practical question: how much software-factory machinery should we build, and where does engineering experience earn its keep?
In 2019, I had the opportunity to study applied AI at USD. I had been working as a software engineer at Apple, alongside teams that included machine learning engineers, and had seen some of what machine learning could do. Studying the ideas behind transformers gave me a different appreciation for where software might go.
The possibility that stayed with me was being able to describe what we wanted in ordinary language and have a system turn that intent into actions a computer could carry out. We had spent our careers expressing those instructions in code. Here was an architecture that suggested a much broader way to communicate with software.
I couldn't have described the product that would eventually make that useful to me. But I remember the feeling that something big was coming. I've been watching for it ever since.
My first twenty-four hours with Devin Bots brought that feeling back. For the first time in my own work, I could see enough of the pieces connected to start managing a software team through conversation in a meaningful way.
For over two years, I’d been using Devin, but now talking with Pam, my product owner bot, felt like working with a product owner at Blizzard. You know that feeling when someone gets the work, asks the right questions, helps you see around corners? That’s what it felt like, plus the relief that neither of us seemed to be hallucinating.
Around that conversation was a team covering DevOps, QA, product engineering, and technical writing. Ada, our technical writer, could document a decision and communicate it to the agents responsible for carrying it out.
On a side note, my favorite bot so far is Grim, the Code Reaper. Grim cleans up dead code and removes feature flags we no longer need, along with the leftover code paths. Every team needs someone who enjoys taking code out.
That felt like a concrete version of the possibility I'd been thinking about in 2019. I still needed everything I'd learned about building software to decide how this team should work.
I've already built an agent swarm
I can hear the objection: we've had agent swarms for a while. Give Claude a few roles, connect some tools, and get the agents talking. What's new?
I've spent more than a year watching teams attempt this. In some cases I've seen spending reach tens of thousands of dollars a month while very little business value emerged.
Some of those LinkedIn posts and YouTube demos remind me of that funny phrase, hustle porn. We could call this its cousin: agent porn.
Someone tells us they've been awake for twenty-four hours building their billion-dollar business. We're supposed to admire the exhaustion before asking whether they've built anything anyone needs. In the agent version, we get twelve terminals, a swarm diagram, and a stream of messages between our new artificial employees.
The appearance of a busy team makes good video. What happens after the recording ends?
Alex Karp put the broader problem plainly: “The appearance of software working is not software working.” The line was reported from Palantir's Q1 2026 earnings call.
The appearance of agent orchestration deserves the same scrutiny. Can the system retain a decision, recover interrupted work, enforce access boundaries, reconcile conflicting changes, and produce evidence that a release is ready? Those are the things I want to inspect before calling it an artificial workforce.
Sometimes what a team has built is a useful set of Markdown instructions running inside an existing coding agent. Those instructions can represent valuable knowledge. But the execution loop, tool access, and context management may come from the underlying platform. Claude Code's own documentation describes that surrounding runtime as the harness. We should be clear about which part we built and which part we configured.
The possibility that interested me when I started my company was humans and software working as teammates. A teammate has a responsibility, can receive a changed decision, and can bring back work we can evaluate. Getting software to do that reliably takes more than arranging a conversation between models.
That was why I kept watching teams like Cognition and Factory. I expected the difficult work to be in making execution, context, coordination, permissions, and verification operate together. Their engineering depth made them worth watching; it didn't exempt their products from the same test.
My first day with Devin Bots was the first time those pieces felt connected enough for me to manage a team through conversation, with the confidence I'd felt working alongside experienced engineers. We could work through a decision, hand it to the right teammate, and watch the team move it forward.
Which brings me to the title. Software factories aren't dead. Factory is building one. Cognition is building one. I'm starting to question why so many of us are trying to build another one from scratch.
One day in, I had an example worth talking about. I also had a bill that reminded me why engineering experience still matters.
An expensive way to ask for quality
We can give an agent a repository and tell it to manage regression testing. Ask it to learn the app, build an end-to-end suite, and keep bugs out. It may do useful work with that instruction.
But we haven't told it when to test, which version to test, or how much testing makes sense after a small fix.
Imagine several coding agents pushing changes throughout the day. QA runs a full regression suite and finds a bug. An agent fixes it. QA starts the entire suite again. Another failure, another fix, another complete run.
An hour-long regression pass can become several hours of repeated work. If an agent is also driving the browser, interpreting results, and investigating failures, the cost includes its time and model usage as well as the test infrastructure.
My first-day spending included about $130 on DevOps, $86 on the technical writer, and $175 on QA. That was enough to make efficiency a real engineering concern. I needed to decide which work deserved another full run.

Give QA a strategy
When I set up QA, I started with the same broad request: understand the repository and build regression coverage for the app. Then I asked it to categorize that coverage by feature and behavior.
The next instruction came from having worked with engineering teams: we need to understand the reach of a change before deciding which tests to repeat.
I had looked at graph tools, including Colby McHenry's CodeGraph and Graphify. I asked QA to discuss the approach with the other engineering agents and work toward connecting code relationships to our regression categories.
The intended workflow is straightforward. A PR changes a part of the application. QA examines the diff, follows related code, checks the architectural documentation, and identifies the behaviors we should retest. After a bug fix, it repeats the relevant checks instead of automatically restarting everything. Before release, we still run the full suite against the release candidate.
That's more useful than asking an agent to make sure we have zero bugs. We have given it a method, tools, and a way to find out when the method is insufficient.
I'm putting this strategy in place now. Next comes measuring which regressions it catches, what it misses, and what it costs.
Ada, please tell the team
The other moment that stood out involved our Git workflow.
I worked with the DevOps agent on a process that would let the bots contribute without blocking our human engineers. Once we agreed on the approach, we asked Ada to document it and distribute it to the other eight bots involved in delivery.
I asked the chief of staff to collect acknowledgments. The bots started reporting back that they had received the new standard and understood how they were expected to work.
My part was working through the decision with DevOps and asking the chief of staff to confirm that it reached the team. Ada handled the documentation and distribution to all eight bots, and their acknowledgments came back without me briefing each one separately.
That felt familiar as an engineering-management activity. A decision became a document, reached the people responsible for acting on it, and had an explicit acknowledgment step.
The next test is whether their branches and PRs follow it. Saying yes to a process and following it under pressure are different things. We've had plenty of practice learning that with human teams.
The appearance of a factory
If we're selling a mid-market company its own software factory, we should explain why its requirements justify custom orchestration infrastructure. What can't an existing platform do? Who maintains our system as models, integrations, and execution environments change?
Without a good answer, we're offering to build a word processor because the client needs to write documents.
There is valuable consulting work in understanding a customer's delivery process, configuring access, improving tests, and deciding which responsibilities agents can own. The customer should know whether they're buying that work or funding another platform that somebody now has to support.
Devin Bots made this coordination accessible in my first day. Factory Workstreams offers a closely related approach with an orchestrator and cooperating agents. I haven't spent comparable hands-on time with Factory, so I can't rank the experience fairly.
Both give us a reason to examine the build-versus-buy decision before we spend months assembling machinery that already exists.
We all have the same AI
A non-engineer once told me they could do what they were paying me to do with Claude Code.
Indeed, we all have access to the same tools. The difference was knowing how to use them on hard problems. In small comparisons, I’ve seen an experienced technical team build roughly ten times faster, with better results, using the same model and comparable equipment as a non-technical team. That’s what I observed in those cases, not a universal productivity ratio.
A side project and a long-running production system ask very different things of us. In Why Software Factories Fail, Dex Horthy examines what happens when faster implementation gets ahead of the engineering judgment needed to keep a codebase maintainable. That is the work I'm talking about here.
The reverse is true when I work in someone else's field. An experienced business operator can recognize a bad assumption that I might spend days exploring. A capable designer can see why an interaction fails before I understand what to ask the agent to change.
QA is a concrete example. Knowing to organize regression coverage, investigate change impact, and retain a release gate gives the agent a better starting point. Knowing where that strategy can fail matters just as much.
I'm aiming for routine QA work closer to $10 a day, with broader release checks budgeted separately. I'll need actual runs to establish the cost and whether the coverage holds up. A cheaper test run that quietly misses regressions hasn't saved us anything.
The useful measure is what we spent to reach an acceptable result, including review and repair. The agent's invoice is only part of it.
I still bet on experienced engineers. These platforms give our decisions more execution behind them. Choosing the wrong direction can now produce a considerable amount of work before we stop it.
Would your team enjoy working this way?
If you're still thinking, “I could build this myself with Claude Code or Codex,” you may be right about the system your team needs. We've been here before in software. Being able to build something is one part of deciding whether we should own it.
DHH (inventor of Ruby on Rails) puts “Optimize for programmer happiness” first in the Rails Doctrine. That's a useful consideration here too. Would your team enjoy working in the system you're proposing? Or would they spend their days tending to its rough edges when they could be solving problems for your business and clients?
A custom system can be a pleasure to use, and a purchased platform can be frustrating. We should judge the actual experience. Put the setup, interruptions, maintenance, and handoffs alongside the feature list. The way we spend our working day deserves a place in that decision.
The last mile for your business
If you're a business owner reading this, I'd encourage you to try these tools yourself. You can get started with Devin or Factory for less than a hundred dollars a month. That buys access, with usage limits, but it's enough to start exploring. Pick a small problem you understand and see how far you get. Devin pricing and Factory pricing describe the current plans.
I think you'll be surprised. You can start putting together an agent team, give it responsibilities, and watch it do useful work. You don't need an agency's permission to discover what's possible.
Then you may reach a point where you can see the value, but you need it to work with your existing systems, handle your exceptions, and meet the standards your customers depend on. That's the last mile for your business, and it can consume much of the time and money.
When I was working at my startup, I encouraged prospective clients to ask a question about any company offering to build software for their business: who is the technical team?
Whoever you work with, that should be your question. Who will understand your business well enough to make the right connections? Who knows how to investigate a failure, evaluate a proposed fix, and decide whether it's ready to release? Ask them to show you comparable work and explain how they'll measure whether this investment helped.
You can buy access to the same tools they use. Their experience should make a difference you can see in the quality of the result, what it costs to deliver, and how well it holds up when people depend on it.
If there's one thing my first twenty-four hours with Devin Bots reinforced for me, it's that expertise still matters. I could give the agents better direction because I understood the work I was asking them to do. I'll get into that over the next few posts, following the decisions, the results, and what it costs to deliver that last mile for a business.