Anvil CoderAnmelden

Der Motor

Vom Ticket zum Pull Request

Du ziehst ein Ticket auf den Start-Zustand, Anvil Coder plant, zerlegt und baut. Zurück kommt ein Draft-Pull-Request in deinem Repository, mit einem Commit je Arbeitsschritt und einem Laufbericht, der sagt, was geprüft wurde.

Ein Ticket in fünf Schritten

  1. Beschreiben: Aufgabe und Akzeptanzkriterien ins Ticket, oder im Spec-Studio erarbeiten.
  2. Planen: Anvil Coder zerlegt die Umsetzung in kleine Schritte, jeder mit genau dem Kontext, den er braucht.
  3. Umsetzen: Agenten erstellen Änderungen und Commits in deinem Repository, unter deinen Guardrails.
  4. Prüfen: Gates melden ihre Ergebnisse in den Laufbericht. Du siehst, was lief und was nicht.
  5. Reviewen: Du öffnest den Draft-Pull-Request bei deinem Code-Host und entscheidest über den Merge.

Einen echten Lauf nachlesen: ein Laravel-Bugfix, drei Commits, Fix und Regressionstest in 24 Minuten.

Am Ende steht ein Repository, kein Vorschlag

Das Ergebnis ist kein Chatverlauf, aus dem jemand Code herauskopiert. Es ist ein Git-Repository mit Historie: jeder Arbeitsschritt hinterlässt seinen Commit, jede Phase ihren Stand. Du liest am Commit, unter welchem Auftrag er entstand, statt zu rekonstruieren, was sich ein Agent gedacht hat. Und was dort liegt, ist prüfbar: von dir, von deiner Pipeline, von einem Auditor.

Systemdiagramm: Tickets und Epics aus YouTrack, GitHub, Jira, GitLab und dem internen Board fliessen in Anvil Coder; heraus kommen Pull Requests auf GitHub, GitLab und Bitbucket; Signale speisen das Dashboard, die Modell-Anbindung ist austauschbar
Der Ablauf auf einen Blick. Gestrichelt, was geplant ist.

Warum kleine Schritte

Ein Sprachmodell hat ein Kontextfenster. Ein echtes Software-Projekt passt nicht hinein, nicht die Anforderungen, nicht der bestehende Code, nicht beides zugleich. Wer trotzdem ein ganzes Projekt in einen Prompt legt, bekommt eine Skizze zurück, kein Programm.

Prompt Slicing ist die Antwort: die Anforderungen werden nicht zusammengefasst, sondern zerlegt. Jeder TaskSlice ist klein genug, dass er vollständig in einen Prompt passt, mitsamt dem Kontext, den genau dieser Schritt braucht. Darum bleibt die Qualität beim zweihundertsten Schritt dieselbe wie beim ersten.

Vor dem Ticket: das Spec-Studio

Nicht jeder Auftrag beginnt als fertiges Ticket. Für den Text, der noch keiner ist, gibt es im Cockpit das Spec-Studio: eine geführte Spezifikation in sieben Abschnitten, vom Ziel über Rollen und Abläufe bis zum Stack-Profil, jeder mit einem Rückfrage-Chat, der Lücken benennt statt sie zu überschreiben. Am Ende entstehen echte Tickets: Epics und Stories in deinem Tracker, auf Wunsch samt neu angelegtem Repository.

Das Studio schreibt Tickets, keinen Code. Welche Story läuft, entscheidest du, Story für Story. Die Anleitung steht in der Dokumentation.

Zwei Achsen: Phasen und Slices

Die Ausführung läuft auf zwei Ebenen, die sich kreuzen. Phasen laufen nacheinander und sind durch Barrieren getrennt: eine Phase beginnt erst, wenn alle Schritte der vorigen fertig sind. TaskSlices laufen innerhalb einer Phase parallel. Das ist der Unterschied zwischen „schneller tippen“ und „mehr gleichzeitig bauen“: die Reihenfolge bleibt, wo sie fachlich zählt, und fällt weg, wo sie nur bremst.

Anforderungen
Aus dem Ticket wird ein geprüftes Anforderungsbild. Offene Punkte stehen als Annahmen im Lauf, nicht zwischen den Zeilen.
Architektur
Struktur, Schnittstellen und Abhängigkeiten stehen fest, bevor die erste Zeile Code entsteht. So baut kein Schritt am anderen vorbei.
Umsetzung
Jeder Arbeitsschritt ist genau ein Prompt auf einem Worker mit eigenem Arbeitsbaum. Das Modell sieht nur, was dieser Schritt braucht.
Abgleich
Die parallel entstandenen Teile werden gegeneinander geprüft und zusammengeführt.
Test
Tests sind eigene Arbeitsschritte, kein Nachgedanke.
Verifikation
Das Ergebnis wird gegen die Anforderungen geprüft, nicht gegen die Absicht, die es erzeugt hat.
Dokumentation
Was gebaut wurde, wird beschrieben, solange der Kontext noch da ist.
Konsistenz
Ein letzter Durchgang über das Ganze: passt zusammen, was getrennt entstand?

Am Ende prüft der Konsistenz-Durchgang das Ganze. Misst er eine Verschlechterung, schickt er die betroffenen Schritte in gedeckelte Reparatur-Runden; kann er nicht messen, lässt er den Lauf durch und vermerkt das am Gate, damit du es im Laufbericht siehst statt es zu übersehen.

Zwei Dinge solltest du wissen: Abgleich, Verifikation und der Build-und-Test-Durchgang sind je Projekt schaltbar und im gemieteten Dienst eingeschaltet, und fehlen deinem Projekt die Build-Werkzeuge in der Sandbox, markiert der Lauf das Ergebnis als unverifiziert, statt es grün zu nennen.

Illustration: ein grosser oranger Block links wird entlang einer Linie zu einer Reihe gleich grosser kleiner Blöcke, ein Epic wird zu Stories
Ein Epic, auf den Start-Zustand gezogen, zerlegt sich selbst in gleich geschnittene User Stories. Welche davon läuft, gibst du einzeln frei.

Was ein Worker tut

Ein Worker nimmt genau einen TaskSlice, führt einen Prompt aus, validiert das Ergebnis und committet es. Kein Worker sieht den Gesamtplan; er sieht seinen Schritt und den Kontext, den dieser Schritt braucht. Den Plan hält der Coordinator, der die Slices über eine dauerhafte Warteschlange verteilt.

Fällt ein Worker aus, geht sein Slice nicht verloren, er wird erneut zugestellt. Staut sich die Warteschlange, kommen Worker dazu; ist sie leer, fährt die Flotte auf null.

Was du während des Laufs siehst

Ein Lauf ist kein schwarzer Kasten. Im Cockpit verfolgst du live, welcher Schritt gerade bearbeitet wird, welche Änderungen entstehen und welche Zwischenschritte das Modell nimmt.

Dazu gehören die Kosten: nicht am Monatsende zusammengefasst, sondern je Schritt einzeln ausgewiesen. Wo die Zeit oder das Geld eines Laufs hingegangen ist, steht im Lauf selbst, nicht in einer Rekonstruktion danach.