Zum Hauptinhalt springen

Wir lassen unsere KI Code schreiben, PRs überprüfen und sich selbst bereitstellen.

Die Geschichte des Aufbaus einer vollständig autonomen Entwicklungs-Pipeline, in der KI ihre eigenen Verbesserungen schreibt, überprüft, testet und ausliefert.

Die Schleife, die sich selbst schloss

  1. Februar 2026. Die Commit-Nachricht lautet: “feat(ci): geschlossene Validierung für autonomen Claude in GitHub Actions hinzufügen.”

Dieses Commit vervollständigte einen Kreislauf, der sich über Wochen aufgebaut hatte. Das Ergebnis: eine vollständig autonome Entwicklungs-Schleife, in der KI Code schreibt, testet, überprüft, einen PR erstellt und das Ergebnis validiert — alles, ohne dass ein Mensch die Tastatur berührt.

So sieht die Schleife aus:

  1. Ein Issue wird auf GitHub eingereicht
  2. Claude liest das Issue und den Code
  3. Claude schreibt einen Fix auf einem neuen Branch
  4. Claude führt die Tests aus
  5. Wenn Tests fehlschlagen, liest Claude die Fehler und behebt den Code
  6. Wenn die Tests bestehen, erstellt Claude einen PR mit einer Zusammenfassung
  7. Eine separate Claude-Instanz überprüft den PR
  8. Ein Mensch überprüft alles und entscheidet, ob er zusammengeführt wird

Die Schritte 1 bis 7 passieren automatisch. Schritt 8 ist die einzige menschliche Intervention.

Wie wir hierher kamen

Das geschah nicht über Nacht. Es wurde schrittweise über sechs Wochen aufgebaut, eine Fähigkeit nach der anderen.

Woche 1: Issue-Resolution (25. Dezember). Wir begannen mit der einfachsten Version: Claude liest ein GitHub-Issue, schreibt einen Fix und pusht einen Branch. Keine Tests. Keine Überprüfung. Nur “hier ist ein Branch mit einem potenziellen Fix, schau dir das an.”

Woche 2: PR-Erstellung (26.-27. Dezember). Anstatt nur einen Branch zu pushen, erstellt Claude einen richtigen Pull Request mit einem Titel, einer Beschreibung und dem verlinkten Issue. Jetzt ist der Fix für das Team sichtbar, ohne manuell Branches überprüfen zu müssen.

Woche 3: Code-Review (Anfang Februar). Ein separater Claude-Workflow wird bei neuen PRs ausgelöst. Er überprüft den Code auf Bugs, Sicherheitsprobleme und Stilverstöße. Kommentare erscheinen im PR, genau wie die Kommentare eines menschlichen Prüfers.

Woche 4: Geschlossene Validierung (3. Februar). Das letzte Puzzlestück: Claude führt die Tests aus, bevor der PR eingereicht wird. Wenn Tests fehlschlagen, liest es die Fehlermeldungen, ändert den Code und versucht es erneut. Der PR wird nur erstellt, wenn die Tests bestanden werden.

Jede Woche fügte eine Schicht hinzu. Jede Schicht machte das gesamte System zuverlässiger.

Was wir über KI-gestützte Entwicklung gelernt haben

Die KI braucht Einschränkungen, keine Freiheit. Früher “behebt” Claude manchmal einen kleinen UI-Bug, indem es drei Module refaktoriert und das Datenbankschema ändert. Wir haben gelernt, explizite Einschränkungen hinzuzufügen: “Ändere nur Dateien, die direkt mit dem Issue zu tun haben. Keine Refaktorisierung. Keine neuen Funktionen. Behebe den Bug.”

Prägnante Zusammenfassungen sind besser als detaillierte Erklärungen. Claudes erste PR-Beschreibungen waren 2.000 Wörter lang. Niemand las sie. Wir haben den Prompt so angepasst, dass Zusammenfassungen unter 200 Wörtern erforderlich sind. “Was hat sich geändert und warum” in zwei Sätzen. Das ist alles, was ein Prüfer braucht, um mit seiner Überprüfung zu beginnen.

Die Code-Überprüfung findet echte Probleme. Wir waren skeptisch, dass eine KI, die KI-generierten Code überprüft, etwas Nützliches finden würde. Das tut sie. Fehlende Fehlerbehandlung. Potenzielle Nullreferenzen. Unbenutzte Importe. Sicherheitsprobleme. Der KI-Codeprüfer ist nicht perfekt, aber er findet 80 % der Probleme, die Menschen bei einem schnellen Scan entdecken — und das in Sekunden.

Trennung der Anliegen ist wichtig. Die KI, die den Code schreibt, und die KI, die den Code überprüft, müssen getrennt sein. Dasselbe Modell, anderer Kontext, anderer Prompt, andere Anliegen. Der Schreiber ist optimistisch (“hier ist meine Lösung”). Der Prüfer ist skeptisch (“was könnte schiefgehen?”). Beide Perspektiven sind notwendig.

Die meta Realität

Lassen Sie uns das Offensichtliche sagen: Wir bauen eine Plattform für autonome KI-Agenten, und wir nutzen autonome KI-Agenten, um sie zu bauen.

Unsere Nutzer betreiben KI-Agenten, die Code in sandboxed Umgebungen ausführen, Dateien lesen und schreiben und Aufgaben autonom erledigen. Unser Entwicklungsprozess läuft mit KI-Agenten, die Code in CI-Umgebungen ausführen, Dateien lesen und schreiben und Aufgaben autonom erledigen.

Der Unterschied ist oberflächlich: Unsere Nutzer verwenden die Weboberfläche von LikeClaw, und unser CI verwendet GitHub Actions. Das zugrunde liegende Muster ist identisch: Definiere eine Aufgabe, lasse die KI sie ausführen, überprüfe die Ergebnisse.

Das ist kein Zufall. Wir haben die Entwicklungs-Pipeline nach denselben Prinzipien aufgebaut, die wir unseren Nutzern beibringen. Und die Dinge, die wir aus dem Betrieb dieser Pipeline lernen, verbessern das Produkt, das wir für sie entwickeln. Es ist ein positiver Kreislauf.

Die Zahlen

Seit der Aktivierung der autonomen Entwicklungs-Pipeline:

  • PRs, die von KI erstellt wurden: Dutzende
  • Durchschnittliche Zeit von Issue zu PR: Minuten, nicht Stunden
  • Testfehler, die vor der Einreichung erkannt wurden: mehrere pro Woche
  • Produktionsvorfälle, die durch KI-generierten Code verursacht wurden: null (bisher)

Diese letzte Zahl ist die, die am meisten zählt. Null Produktionsvorfälle. Jede KI-generierte Änderung durchlief Tests, KI-Überprüfung und menschliche Überprüfung, bevor sie zusammengeführt wurde. Das dreischichtige Sicherheitsnetz funktioniert.

Das ist erst der Anfang

Heute kümmert sich die KI um Bugfixes, Abhängigkeitsupdates und einfache Feature-Implementierungen. Morgen wird sie komplexere Aufgaben übernehmen: Refaktorisierung über mehrere Dateien, Leistungsoptimierung, Testgenerierung.

Die wichtige Erkenntnis ist nicht, dass KI Code schreiben kann. Es ist, dass KI an einem Entwicklungsworkflow mit den richtigen Leitplanken teilnehmen kann. Tests, Überprüfungen und menschliche Aufsicht machen KI-generierten Code sicher. Entferne eine dieser Schichten und du hast ein Risiko. Halte alle drei und du hast ein Werkzeug, das die Produktivität deines Teams vervielfacht.

Wir sind ein kleines Team, das 7,5 Commits pro Tag ausliefert. Einige dieser Commits sind von Menschen geschrieben. Einige sind von KI geschrieben. Alle wurden von Menschen genehmigt.

Das ist die Zukunft der Softwareentwicklung. Nicht KI, die Entwickler ersetzt. KI, die Entwickler beschleunigt. Mit den richtigen Leitplanken. Um 3 Uhr morgens. Während das Team schläft.

Die autonome Entwicklungs-Pipeline

  1. 1

    Problem gemeldet

    Ein Fehler wird über GitHub Issues gemeldet oder eine Funktion angefragt. Das kann von einem Benutzer, einem Teammitglied oder automatisierter Überwachung kommen.

  2. 2

    KI liest und versteht

    Claude liest das Problem, erkundet den Code, identifiziert die relevanten Dateien und entwickelt einen Lösungsansatz.

  3. 3

    Code ist geschrieben

    Claude schreibt den Fix oder das Feature in einem neuen Branch. Es führt die Test-Suite aus. Wenn die Tests fehlschlagen, behebt es den Code und versucht es erneut.

  4. 4

    PR wird erstellt und überprüft.

    Ein automatisierter PR wird mit einer prägnanten Zusammenfassung erstellt. Eine separate Claude-Instanz überprüft den Code auf Bugs, Sicherheit und Stil.

  5. 5

    Mensch genehmigt

    Ein Mensch überprüft den PR, die Code-Review-Kommentare der KI und die Testergebnisse. Dann führt er die Zusammenführung durch oder fordert Änderungen an.

Vorher

Entwicklung ohne AI im Loop

  • Das Problem sitzt tagelang oder wochenlang im Backlog.
  • Entwickler verbringen über 30 Minuten damit, den Kontext zu verstehen.
  • Code-Reviews dauern oft Stunden des Wartens.
  • Einfache Bugs fressen ganze Morgenblöcke auf.

Nach

Entwicklung mit KI im Loop

  • Das Problem hat innerhalb von Minuten einen PR erhalten.
  • Die KI hat bereits die Codebasis erkundet und Tests geschrieben.
  • Code-Reviews sind sofort — Menschen überprüfen nur die Überprüfung.
  • Einfache Bugs werden behoben, bevor das Team aufwacht.

Fragen zur KI-gestützten Entwicklung

Wie viel deines Codes wurde von KI geschrieben?

Es variiert. Routine-Bugfixes, Abhängigkeitsupdates und einfache Funktionen werden größtenteils von der KI geschrieben und von Menschen überprüft. Architektonische Entscheidungen, komplexe Funktionen und sicherheitsrelevanter Code werden von Menschen geschrieben und von der KI überprüft. Das Verhältnis ändert sich von Woche zu Woche.

Was verhindert, dass die KI schlechte Änderungen vornimmt?

Drei Ebenen: automatisierte Tests, die bestanden werden müssen, eine KI-Codeüberprüfung, die nach Problemen sucht, und eine obligatorische menschliche Genehmigung vor dem Mergen. Die KI pusht niemals direkt in den Hauptbranch.

Können deine Nutzer das auch?

Die gleichen Prinzipien gelten. LikeClaw-Nutzer können Hintergrundagenten einrichten, die Code schreiben, Repositories analysieren und Berichte erstellen. Die Tools, die wir intern verwenden, sind die gleichen Tools, die wir den Nutzern anbieten.