Wenn ich mit Kunden über eine «Software Factory» spreche, sehe ich oft Skepsis. Das klingt nach einem Grossprojekt, nach einer eigenen Plattform, nach zwei Jahren Aufbau, bevor die erste Zeile Code entsteht. Die Skepsis ist verständlich. Aber sie hat mehr mit dem Wort zu tun als mit der Sache.
In meinem letzten Artikel Keine Fabrik: Warum KI-Entwicklung eine Werkstatt ist habe ich geschrieben, warum KI-Entwicklung keine Fabrik ist, sondern eine Werkstatt. Wie die Werkstatt des Weihnachtsmanns: Der Weihnachtsmann orchestriert, die Elfen sind die Agenten, und der Wunschzettel ist die Spezifikation. In diesem Artikel geht es um die Frage, warum so viele eine Software Factory für schwierig halten. Und warum eine Software-Werkstatt einfach ist.
Warum eine Software Factory schwierig wirkt
Ich sehe sechs Gründe. Keiner davon ist technisch.
Das Wort. «Fabrik» weckt Bilder von Fliessbändern, grossen Investitionen und langer Planung. Wer «Software Factory» hört, denkt an eine Plattform, die man zuerst bauen muss, bevor man einen Nutzen hat.
Die alten Erfahrungen. Die Idee ist nicht neu. Um 2004 gab es die «Software Factories» von Microsoft, dazu MDA und modellgetriebene Entwicklung. Sie haben viel versprochen. Am Ende standen oft schwere Werkzeuge, eigene DSLs und Generatoren, die nur zwei Leute im Team verstanden. Wer das erlebt hat, ist vorsichtig. Zu Recht.
Alles auf einmal. Viele glauben, eine Software Factory muss jeden Schritt automatisieren: Anforderungen, Code, Tests, Deployment und Betrieb. So wird aus einer guten Idee ein Programm mit Lenkungsausschuss.
Werkzeug statt Methode. Oft wird die Software Factory mit einem Produkt gleichgesetzt: einer Plattform, einem Portal, einem Low-Code-Tool. Der Kern ist aber kein Werkzeug. Der Kern ist ein wiederholbarer Weg vom Bedarf zur laufenden Software.
Die Organisation. Standardisierung heisst, dass Teams etwas Freiheit abgeben. Das ist eine Frage von Kultur und Führung. Das macht es schwierig, nicht die Technik.
Der Hype. Heute heisst es «AI Software Factory», mit Flotten von autonomen Agenten. Das klingt nach Raketenwissenschaft. Und es wird gerne so verkauft, denn Komplexität verkauft Beratung und Lizenzen.
Die Werkstatt des AI Unified Process
Die Software-Werkstatt des AI Unified Process ist im Kern eine CI-Pipeline. Sie baut die genehmigten Use Cases eines Change-Branches. Mehr nicht.
Das Prinzip ist einfach: ein Branch pro Änderung. In diesem Branch liegen Spezifikation, Code und Tests zusammen. Ein Use Case mit dem Status «Approved» ist ein Auftrag an die Werkstatt. Die Agenten setzen ihn um, schreiben die Tests und prüfen das Ergebnis gegen die Spezifikation. Am Ende steht ein Pull Request, den ein Mensch beurteilt.
Schauen wir die sechs Gründe von oben noch einmal an:
- Keine neue Plattform. Git, eine CI-Pipeline und die Skills des AI Unified Process sind schon da. Man baut nichts Grosses, bevor man einen Nutzen hat.
- Kein eigener Generator, keine eigene DSL. Der Input sind Use Cases und ein Entitätenmodell in Markdown. Fachexperten können sie lesen und schreiben. Den Code schreibt der Agent. Das grosse Problem von MDA, Generatoren, die niemand versteht, fällt weg.
- Nicht alles auf einmal. Die Arbeitseinheit ist ein Use Case. Man kann mit einem einzigen anfangen.
- Methode vor Werkzeug. Die Werkstatt setzt nur um, was der AI Unified Process schon beschreibt. Die Pipeline ist austauschbar, die Methode bleibt.
- Die Organisation ist Teil der Methode. Wer was macht, ist klar geregelt. Dazu weiter unten mehr.
- Kein Hype nötig. Keine Flotte von Agenten, kein Dashboard mit Leuchtanzeigen. Ein Branch, eine Pipeline, ein Pull Request.
Schablonen und Lehren
Eine Werkstatt arbeitet nicht ohne Regeln. Ein Schreiner hat Schablonen, die das Werkstück führen, bevor er sägt. Und er hat Lehren, mit denen er nachher prüft, ob das Mass stimmt. Genau das braucht auch ein Agent.
Schablonen führen den Agenten vorher:
- die Stack-Datei, die festlegt, mit welchen Technologien und Skills jede Schicht gebaut wird
- die Architektur und die Konventionen des Projekts
- die Use Cases, die Geschäftsregeln und das Entitätenmodell
Lehren prüfen das Ergebnis nachher:
- die Tests, abgeleitet aus der Spezifikation und nicht aus dem Code
- der Coverage-Check, der zeigt, ob jeder Schritt, jeder alternative Ablauf und jede Geschäftsregel umgesetzt und getestet ist
- das Spec-Review, das Lücken und Widersprüche in der Spezifikation findet
Das Schöne daran: Man kann es in zwei Sätzen erklären, auch dem Management. Die Schablonen sorgen dafür, dass der Agent das Richtige baut. Die Lehren sorgen dafür, dass wir es merken, wenn er es nicht tut.
Wer in der Werkstatt was macht
Die meisten Software-Factory-Projekte scheitern nicht an der Technik, sondern an unklaren Rollen. In der Werkstatt sind sie klar:
| Rolle | In der Werkstatt des Weihnachtsmanns | Aufgabe |
|---|---|---|
| Fachexperten | die Kinder, die den Wunschzettel schreiben | schreiben die Spezifikation: Use Cases, Geschäftsregeln, Daten |
| Software Engineer | der Handwerker, der die Werkstatt einrichtet | verantwortet Architektur und Harness, prüft das Ergebnis |
| Orchestrator | der Weihnachtsmann | verteilt die genehmigten Use Cases an die Agenten |
| Agenten | die Elfen | setzen die Use Cases selbständig um und schreiben die Tests |
Der Software Engineer führt die Agenten nicht Schritt für Schritt. Er baut die Umgebung, in der sie arbeiten, und er ist für das Resultat verantwortlich. Und die Fachexperten bekommen mehr Gewicht als früher, denn die Spezifikation ist jetzt der wichtigste Input.
Klein anfangen
Eine Werkstatt braucht keinen Businessplan. So fangt ihr an:
- Legt einen festen Stack fest und haltet ihn in der Stack-Datei fest.
- Nehmt einen einzigen Use Case und spezifiziert ihn sauber, zusammen mit den Fachexperten.
- Erstellt einen Branch für diese Änderung und lasst den Agenten Code und Tests schreiben.
- Prüft das Ergebnis mit den Lehren: Tests, Coverage-Check, Review.
- Wiederholt das mit dem nächsten Use Case. Erst wenn es von Hand läuft, kommt die Pipeline dazu.
Nach ein paar Use Cases seht ihr, wo die Schablonen noch nicht genau genug sind. Die verbessert ihr. So wächst die Werkstatt mit jedem Auftrag, statt vorher auf dem Papier geplant zu werden.
Fazit
Eine Software Factory wirkt schwierig, weil wir sie als Fabrik denken: gross, teuer, starr. Eine Software-Werkstatt ist das Gegenteil. Sie ist klein, handwerklich und beherrschbar. Sie hat gute Schablonen und Lehren, und trotzdem entsteht jedes Stück nach Mass.
Mit KI ist das einfacher geworden als je zuvor. Wir brauchen keine eigenen Generatoren mehr. Eine gute Spezifikation, ein fester Stack und klare Regeln reichen.
Die Schwierigkeit liegt also nicht in der Technik. Sie liegt im Mut, klein anzufangen und konsequent zu bleiben.
Eine Software Factory ist (zu) kompliziert. Eine Software-Werkstatt nicht.


