Blog[Anleitung] 10 Min. Lesezeit

So baust du eine Software Factory mit Claude Code (2026)

Software Factories, auch Dark Factories genannt, sind gerade überall. Du schreibst einmal die Spezifikation, und der Rest läuft automatisch in einer abgeschotteten Umgebung: prüfen, entwickeln, testen, Pull Request. Hier zeige ich dir, wie meine Factory aufgebaut ist und wie du sie dir kopierst.

Lieber zuschauen? Beim Abspielen wird das Video von YouTube geladen. Dabei werden Daten an Google übertragen, mehr dazu in der Datenschutzerklärung.Auf YouTube ansehen ↗

Software Factories beziehungsweise Dark Factories sind gerade absolut im Trend, und viele von euch haben sich mehr Inhalte dazu gewünscht. In diesem Artikel geht es darum, was eine Software Factory ist, wie du mit Claude Code und anderen Coding Agents deine eigene umsetzt und wie sie deine Arbeit mit Agents konsistenter, messbarer und skalierbarer macht.

Gerade wenn du regelmäßig Software für Kunden oder im eigenen Unternehmen entwickelst, kann eine Factory deine Produktivität deutlich erhöhen. Du arbeitest mit dem Agent nur noch die Spezifikation aus, der Rest passiert automatisch in einer abgeschotteten Umgebung. Jede Aufgabe durchläuft denselben standardisierten Prozess, und weil jeder Lauf gemessen wird, kannst du ihn gezielt verbessern.

Meine Factory ist Open Source (MIT-Lizenz). Du kannst sie dir also komplett kopieren.

Was ist eine Software Factory?

Eine Factory ist im Kern ein Repository, das seinen eigenen Code ausliefert: Du gibst eine Spezifikation hinein, und am Ende kommt fertiger, geprüfter Code heraus. Dark Factory heißt das Ganze, weil der Mensch aus dem Ablauf herausgenommen wird und alles theoretisch autonom läuft.

Der Ablauf sieht so aus:

  1. Warteschlange: Aufträge warten auf ihre Bearbeitung. In festen Abständen schaut ein Mechanismus nach, ob es neue gibt.
  2. Eingangsprüfung: Eine neue Spezifikation wird unter die Lupe genommen und darf auch abgelehnt werden, zum Beispiel wenn Informationen fehlen.
  3. Planung, Umsetzung und Qualitätssicherung.
  4. Auslieferung als Pull Request.

Dazwischen gibt es gewollte Haltepunkte, etwa wenn der Agent eine Rückfrage hat. Das verhindert, dass er bei Unsicherheit eigene Annahmen trifft. So kannst du mehrere Projekte parallel anstoßen und sie nach und nach von der Factory entwickeln lassen, mit reproduzierbaren Ergebnissen in einer von dir festgelegten Qualität.

Warum ein eigener Server?

Die Factory läuft nicht auf deinem lokalen Rechner. Sie soll arbeiten, wenn du nicht am Rechner sitzt, und sie soll in einer gesicherten Umgebung laufen. Ein eigener virtueller Server (VPS) kostet nur ein paar Euro im Monat und bewahrt dich davor, dass ein Agent destruktive Befehle auf deinem Laptop ausführt.

Ich nutze den KVM 2 von Hostinger mit 2 CPU-Kernen und 8 GB Arbeitsspeicher. Das reicht, damit die Factory mehrere Aufgaben parallel bearbeitet und nebenbei Prüfungen, Abnahmen und Vorschauen laufen. Hostinger bietet dafür eine Vorlage „Ubuntu 24.04 mit Claude Code“ an, bei der Claude Code schon vorinstalliert ist. Server holen kannst du dir über hostinger.com/alexclaude*, mit dem Code ALEXCLAUDE sparst du 10 % auf Jahrespläne. Es gibt eine 30-Tage-Geld-zurück-Garantie.

Werbung: Hostinger hat das Video gesponsert. Der mit * markierte Link ist ein Provisionslink.

Die Architektur im Überblick

Die Factory besteht grob aus drei Bereichen:

  • Dein Rechner: Hier arbeitest du lokal mit Claude Code und schreibst die Spezifikation für ein neues Feature. Ist sie fertig, übergibst du sie mit einem einzigen Befehl an die Factory.
  • GitHub: Dort liegt der Code, und dort liegt die Aufgabe als Issue, also als Ticket. Am Ende landet hier auch der Pull Request mit dem umgesetzten Code.
  • Dein Server: Darauf läuft ein kleines Programm, der Runner. Er schaut jede Minute bei GitHub nach neuen Aufgaben.

Der Runner verteilt nur die Arbeit, den Code schreiben die Agents. Das ist bewusst so gewählt, denn für die Zuordnung braucht der Runner keine Intelligenz, er entscheidet allein anhand des Status. Für jede Aufgabe startet er einen eigenen Docker-Container, also eine abgeschottete Umgebung mit Claude Code, Git und einem Browser zum Testen. So kommen sich die Agents nicht in die Quere.

Jede Aufgabe durchläuft drei getrennte Läufe:

  1. Prüflauf: Enthält die Aufgabe alle Informationen, um entwickelt zu werden?
  2. Entwicklungslauf: Hier ist festgelegt, wie die Factory entwickelt. Bei mir kommt erst ein Architekturdesign, dann die Umsetzung. Dieser Teil ist austauschbar. Du kannst eigene Skills oder Frameworks wie Superpowers, GSD oder den Workflow von Matt Pocock einsetzen.
  3. Abnahme: Ein unabhängiger Agent prüft das Ergebnis und schickt es bei Bedarf mit Befunden zurück in die Entwicklung.

Ist alles durch, bekommst du einen Pull Request inklusive Vorschau-Link. Du klickst dich selbst durch den Stand, nimmst ab und mergst in die stabile Version.

Den Server einrichten

Auf dem Server braucht die Factory Docker für die Container, Claude Code für die Agents, die GitHub CLI zum Lesen von Aufgaben und Erstellen von Pull Requests sowie Node und Bun für den Runner. Das klingt nach viel, aber ein Setup-Skript erledigt das automatisch:

bash
git clone https://github.com/AlexPEClub/software-factory.git /opt/software-factory
cd /opt/software-factory
./setup.sh

Vorher verbindest du dich per SSH mit deinem Server. SSH ist im Prinzip eine Fernsteuerung über das Terminal. Den passenden Befehl findest du im Hostinger-Panel in der Übersicht deines Servers. Das Skript installiert Docker, die GitHub CLI und alles Weitere, baut das Image für die Container und richtet den Runner als Dienst ein.

Danach fehlen zwei Anmeldungen:

  1. Claude: Auf deinem Rechner erzeugst du mit claude setup-token einen Token und legst ihn auf dem Server ab. Weil die Factory die offizielle, unveränderte Claude Code CLI nutzt, läuft sie mit deinem normalen Claude-Abo. Behalte im Hinterkopf, dass jede Aufgabe dieselben Limits verbraucht wie deine normale Arbeit mit Claude. Für Teams oder wenn du die Factory für Kunden betreibst, empfiehlt Anthropic einen API-Key.
  2. GitHub: Mit gh auth login -s project darf die Factory Aufgaben lesen, Branches pushen, Pull Requests öffnen und das Board aktualisieren.

Danach bindest du dein Repository an. Das legt die Status-Labels an, erstellt beim ersten Mal das Kanban-Board und verknüpft beides. Für jedes weitere Projekt wiederholst du das. Die genauen Befehle stehen in der Schritt-für-Schritt-Anleitung.

Playbook und Entwicklungsworkflow

Die Factory ist nur so gut wie die Anweisungen, die ihre Agents bekommen. Es gibt zwei Ebenen.

Das Playbook

Das Playbook enthält die festen Regeln für jeden Lauf, egal in welchem Projekt:

  • Jeder Schritt wird dokumentiert, damit du immer siehst, wo die Aufgabe steht.
  • Ist etwas unklar, wird nachgefragt statt geraten.
  • Die Spezifikation wird nie verändert, denn sie ist der Vertrag mit Claude Code.
  • Die Factory mergt nie selbst. Das will ich komplett in der Hand haben.

Der Entwicklungsworkflow

Die zweite Ebene beschreibt, wie entwickelt wird. Ich nutze den Workflow aus meinem AI Coding Starter Kit mit vier Schritten, jeweils mit eigenem Skill:

  1. Spezifikation (lokal): Mit dem Skill /write-spec stellt mir Claude so lange Fragen, bis klar ist, was das Feature können soll. Heraus kommen User Stories, Akzeptanzkriterien und Sonderfälle. Mit /to-factory übergebe ich die fertige Spec an die Factory.
  2. Architektur: Welche Komponenten braucht das Feature, was ist schon da, was lässt sich wiederverwenden?
  3. Umsetzung.
  4. Abnahme.

Die Akzeptanzkriterien sind der wichtigste Teil der Spezifikation. Jedes ist ein konkreter, testbarer Satz, zum Beispiel für eine Kundenübersicht: „Angenommen, die Liste ist leer, wenn die Seite lädt, dann wird eine passende Meldung angezeigt.“ Genau danach testet Claude später. Ein Spec-Template zum Mitnehmen findest du im Artikel zu macOS-Apps mit AI.

Jeder Schritt bekommt eine eigene Datei: Spezifikation, Architektur und Testbericht liegen getrennt. So kannst du später genau nachvollziehen, was geplant war und was geprüft wurde.

Eine unabhängige Abnahme

Ein Agent, der entwickelt und gleichzeitig prüft, bewertet sein eigenes Ergebnis gern positiv. Deshalb gibt es eine getrennte Abnahme:

  • Schon vor der Entwicklung schreibt ein Agent Testszenarien zu den Akzeptanzkriterien. Der Entwicklungs-Agent bekommt sie nie zu sehen, damit er nicht auf die Prüfung hin optimiert.
  • Nach der Umsetzung startet ein komplett neuer Agent in seinem eigenen Container. Er kennt nur Spezifikation, Szenarien und Ergebnis, startet die App und testet jedes Szenario im Browser.
  • Findet er etwas, geht die Aufgabe mit den Befunden zurück in die Entwicklung. Erst wenn die Abnahme bestanden ist, landet der Pull Request bei dir.

Das ist auch der größte Vorteil einer Factory, gerade im Team oder in einer Agentur. Normalerweise arbeitet jeder mit eigenem Setup, eigenen Prompts, Skills und Modellen. In der Factory durchläuft jedes Projekt denselben Ablauf. Verbesserst du das Playbook oder einen Skill, wirkt das auf jede Aufgabe in jedem Projekt. Warum das bei produktiver Software wichtig ist, liest du im Artikel zu Code-Qualität mit Claude Code.

GitHub als Steuerzentrale

Weil alles im Hintergrund passiert, brauchst du eine Übersicht. Ich nutze dafür GitHub Issues und ein Kanban-Board in GitHub Projects. Ein Issue ist im Prinzip ein Ticket zum Repository, mit Titel, Beschreibung, Kommentaren und Labels. Der Code liegt dort ohnehin, deshalb ist das die einfachste Lösung.

Die Spalten auf dem Board:

StatusWas passiert
NeuDie Aufgabe ist angelegt und wird sofort geprüft.
In PrüfungGibt es eine Spezifikation, ist jedes Akzeptanzkriterium testbar, widerspricht sich etwas?
RückfrageEine Kleinigkeit ist unklar. Die Factory stellt im Issue eine konkrete Frage mit zwei, drei Optionen. Du antwortest, und es wird neu geprüft.
AbgelehntDie Aufgabe ist so nicht umsetzbar, etwa weil die Spezifikation fehlt.
FreigegebenDie Factory übernimmt, sobald ein Platz frei ist. Wie viele Aufgaben parallel laufen, hängt von deinem Server ab.
In ArbeitArchitektur, Umsetzung und Tests laufen. Im Issue siehst du jederzeit den aktuellen Schritt.
AbnahmeDer unabhängige Agent prüft das Ergebnis.
ReviewDu bist dran: anschauen und gegebenenfalls mergen.
FehlgeschlagenEin technisches Problem, zum Beispiel ein fehlgeschlagener Build. Der Agent dokumentiert es im Kommentar. Du antwortest, und der Prozess läuft weiter.

Ein neues Projekt in der Factory starten

Für neue Projekte gibt es eine Projektvorlage und ein paar lokale Skills, die du einmal auf deinem Rechner installierst. Ein Befehl legt das Repository aus der Vorlage an und meldet es direkt bei deiner Factory an.

Dann geht es so weiter:

  1. Briefing: In der Vorlage gibt es eine Datei für dein Projekt-Briefing. Da kommt alles rein, was du schon weißt: Notizen, Anforderungen, Kundenbriefing.
  2. /init: Der Skill liest das Briefing, fragt nach, was noch fehlt, legt Tech-Stack und Design fest und erstellt eine Liste aller Features. Am Ende setzt er das Grundgerüst der App auf und legt fest, wie die Factory das Projekt installiert und testet.
  3. Pro Feature: Mit /write-spec die Spezifikation erarbeiten, selbst prüfen und mit /to-factory übergeben. Der Skill legt ein Issue mit dem Label factory an, das der Factory signalisiert: Diese Aufgabe darf automatisch bearbeitet werden.

Ab dann übernimmt die Factory. Am Ende bekommst du einen vollständigen Pull Request: was umgesetzt wurde, jedes Akzeptanzkriterium mit Ergebnis, die Annahmen der Factory, die Ergebnisse der automatischen Prüfungen und Screenshots. Ganz unten steht eine Einschätzung, wo du genauer hinschauen solltest.

Für jeden Pull Request startet die Factory außerdem eine passwortgeschützte Vorschau auf deinem Server. Gefällt dir etwas nicht, kommentierst du einfach, und die Factory arbeitet am selben Pull Request weiter, bis alles passt.

Messen und verbessern

Weil jede Aufgabe denselben Ablauf durchläuft, lässt sich messen, wie gut die Factory arbeitet. Jeder Lauf wird mit Dauer, Schritten und Ergebnis festgehalten. Mit factory-stats siehst du zum Beispiel, wie lange eine Aufgabe im Schnitt braucht, wie oft die Prüfung Rückfragen hat und wie oft die Abnahme beim ersten Mal besteht.

Spannend ist das vor allem, wenn du etwas änderst, etwa die Regeln im Playbook oder das Modell für die Umsetzung. Dann lässt du das ein paar Tage laufen und siehst, ob es etwas bringt.

Was du wissen solltest

  • Abo-Limits: Nutzt du die Factory intensiv, merkst du das in deinen Limits. Sammle erst Erfahrungswerte und behalte das im Blick.
  • Die Spezifikation entscheidet: Je klarer Anforderungen und Akzeptanzkriterien sind, desto besser das Ergebnis. Hier solltest du die meiste Zeit investieren.
  • Nicht für jede Aufgabe: Will ich etwas Neues ausprobieren, am Design feilen oder eine Idee zum ersten Mal mit Claude durchdenken, mache ich das lokal. Da will ich nah am Code sein und schnell iterieren. In die Factory gehen nur klar umrissene, klar spezifizierte Aufgaben.
  • Nicht blind mergen: Manche lassen Pull Requests komplett automatisch mergen. Mit dem richtigen Prozess ist eine gewisse Qualität gewährleistet, die Factory testet gründlich und ein Agent nimmt ab. Trotzdem würde ich zumindest Stichproben machen, bevor du Ergebnisse übernimmst.
  • Frühe Version: Die Factory ist in einem sehr frühen Stadium. Nutze sie als Startpunkt und als Inspiration für deine eigenen Prozesse. Zum Testen kannst du sie auch lokal mit Docker starten.

Die Factory zum Kopieren

Wie du die einzelnen Bausteine rund um deine Agents gestaltest, erkläre ich im Artikel zu Harness Engineering. Und wenn du dir einen festen, prüfbaren Ablauf für deine Coding Agents aufsetzen willst, schau dir meinen kostenlosen AI Engineering Blueprint an.

Häufige Fragen

Was ist eine Software Factory?

Eine Software Factory ist ein Repository, das seinen eigenen Code ausliefert: Du gibst eine Spezifikation hinein, und am Ende kommt fertiger, geprüfter Code als Pull Request heraus. Von einer Dark Factory spricht man, wenn der Mensch aus dem Ablauf herausgenommen wird und alles theoretisch autonom läuft.

Kann ich mein Claude-Abo für die Factory nutzen?

Ja, wenn die Factory die unveränderte, offizielle Claude Code CLI startet und du dich mit deinem eigenen Abo über claude setup-token anmeldest, den Weg, den Anthropic für Skripte und CI dokumentiert. Die Factory verbraucht dabei dieselben Limits wie deine normale Claude-Nutzung. Für Teams oder den Betrieb für andere empfiehlt Anthropic einen API-Key.

Warum läuft die Factory nicht auf meinem Laptop?

Die Factory soll arbeiten, wenn du nicht am Rechner sitzt, und Agents sollen keine destruktiven Befehle auf deinem eigenen Rechner ausführen können. Ein eigener virtueller Server läuft rund um die Uhr, und jede Aufgabe bekommt dort einen eigenen Docker-Container. Zum Ausprobieren kannst du die Factory aber auch lokal mit Docker starten.

Mergt die Factory den Code selbst?

In meinem Setup nicht. Die Factory erstellt einen Pull Request mit Belegen und einer passwortgeschützten Vorschau, gemergt wird immer von mir. Das ist eine Regel im Playbook und lässt sich anpassen, ich empfehle aber zumindest Stichproben, bevor du Ergebnisse übernimmst.

[Mein Programm] AI Engineering Accelerator

Vom Vibe Coder zum AI Engineer

Wenn du Software entwickeln willst, die du an Kunden verkaufst, brauchst du mehr als gute Prompts. Im Accelerator lernst du, mit System zu entwickeln: mit Struktur, Qualitätssicherung und einer Community, die dich begleitet.

  • Du entwickelst mit Claude Code ein komplettes SaaS-Produkt, von der Idee bis zum sicheren Live-Betrieb.
  • Ein fertiges AI Engineering Framework hält Claude auf Kurs, auch wenn dein Projekt wächst.
  • Auth, Datenbank, Deployment und Monitoring: so, dass es mit echten Nutzer:innen hält.
  • Für Founder und Produktteams, ohne selbst zu programmieren.