When I talk with customers about a “software factory”, I often see doubt. It sounds like a big program, a platform of its own, and two years of setup before the first line of code. The doubt is understandable. But it has more to do with the word than with the thing.

In my last article, Not a Factory: Why AI Development Is a Workshop, I wrote why AI development is not a factory but a workshop. Like Santa’s workshop: Santa orchestrates, the elves are the agents, and the wish list is the spec. This article is about why so many people think a software factory is complicated. And why a software workshop is not.

Why a software factory seems complicated

I see six reasons. None of them is technical.

The word. “Factory” brings up pictures of assembly lines, big investments and long planning. When people hear “software factory”, they think of a platform they must build first, before it gives them any value.

Old experiences. The idea is not new. Around 2004 there were Microsoft’s “Software Factories”, along with MDA and model-driven development. They promised a lot. In the end, there were often heavy tools, custom DSLs and generators that only two people on the team understood. Whoever lived through that is careful. And rightly so.

Everything at once. Many people believe a software factory must automate every step: requirements, code, tests, deployment and operations. This turns a good idea into a program with a steering committee.

Tool instead of method. A software factory is often seen as a product: a platform, a portal, a low-code tool. But the core is not a tool. The core is a repeatable way from a need to running software.

The organization. Standardization means that teams give up some freedom. That is a question of culture and leadership. This is what makes it hard, not the technology.

The hype. Today it is called an “AI software factory”, with fleets of autonomous agents. That sounds like rocket science. And it is often sold that way, because complexity sells consulting and licenses.

The AI Unified Process workshop

The software workshop of the AI Unified Process is, at its core, a CI pipeline. It builds the approved use cases of a change branch. Nothing more.

The principle is simple: one branch per change. This branch holds the spec, the code and the tests together. A use case with the status “Approved” is an order for the workshop. The agents implement it, write the tests and check the result against the spec. At the end, there is a pull request that a human reviews.

Let’s look at the six reasons from above again:

  • No new platform. Git, a CI pipeline and the AI Unified Process skills are already there. You don’t build anything big before you get value.
  • No custom generator, no custom DSL. The input is use cases and an entity model in Markdown. Domain experts can read and write them. The agent writes the code. The big problem of MDA, generators nobody understands, is gone.
  • Not everything at once. The unit of work is one use case. You can start with a single one.
  • Method before tool. The workshop only automates what the AI Unified Process already describes. The pipeline can be replaced, the method stays.
  • The organization is part of the method. Who does what is clearly defined. More on this below.
  • No hype needed. No fleet of agents, no dashboard with flashing lights. One branch, one pipeline, one pull request.

Jigs and gauges

A workshop does not work without rules. A carpenter has jigs that guide the workpiece before he cuts. And he has gauges to check afterwards that the measurements are right. An agent needs exactly the same.

Jigs guide the agent before:

  • the stack file, which defines the technologies and skills used to build each layer
  • the architecture and the conventions of the project
  • the use cases, the business rules and the entity model

Gauges check the result after:

  • the tests, derived from the spec and not from the code
  • the coverage check, which shows whether every step, every alternative flow and every business rule is implemented and tested
  • the spec review, which finds gaps and contradictions in the spec

The nice thing is: you can explain it in two sentences, even to management. The jigs make sure the agent builds the right thing. The gauges make sure we notice when it doesn’t.

Who does what in the workshop

Most software factory projects don’t fail because of technology, but because of unclear roles. In the workshop, they are clear:

RoleIn Santa’s workshopTask
Domain expertsthe children who write the wish listwrite the spec: use cases, business rules, data
Software engineerthe craftsman who sets up the workshopowns the architecture and the harness, checks the result
OrchestratorSantahands the approved use cases to the agents
Agentsthe elvesimplement the use cases on their own and write the tests

The software engineer does not guide the agents step by step. He builds the environment they work in, and he is responsible for the result. And the domain experts get more weight than before, because the spec is now the most important input.

Start small

A workshop doesn’t need a business plan. This is how you start:

  1. Choose a fixed stack and record it in the stack file.
  2. Take a single use case and specify it carefully, together with the domain experts.
  3. Create a branch for this change and let the agent write the code and the tests.
  4. Check the result with the gauges: tests, coverage check, review.
  5. Repeat this with the next use case. Only when it works by hand, add the pipeline.

After a few use cases, you will see where the jigs are not precise enough yet. Improve them. This way the workshop grows with every order, instead of being planned on paper first.

Conclusion

A software factory seems complicated because we think of it as a factory: big, expensive, rigid. A software workshop is the opposite. It is small, built on craft and easy to manage. It has good jigs and gauges, and still every piece is made to measure.

With AI, this has become easier than ever. We no longer need our own generators. A good spec, a fixed stack and clear rules are enough.

So the difficulty is not the technology. It is the courage to start small and stay consistent.

A software factory is (too) complicated. A software workshop is not.