← Alle Artikel

Loopwright — ein agiles Team in einer Box

Loopwright — an Agile Team in a Box

Prompt Engineering ist tot. Es lebe Loop Engineering.

Ich habe mehr angefangene Projekte als freie Abende. Jedes einzelne wäre in zwei Wochen fertig — wenn ich zwei Wochen am Stück daran säße. Tue ich nicht. Ich sitze zwanzig Minuten daran, dann kommt der nächste Kontextwechsel, und wenn ich zurückkomme, ist die erste halbe Stunde Suchen: Wo stand ich? Was war der Plan? Warum ist der Test rot?

Loopwright ist meine Antwort darauf. Kein KI-Knopf an einem Ticket-System, sondern das Umgekehrte: ein Ticket-System, das von einem Team aus KI-Rollen abgearbeitet wird. Ich bringe Ziel und Prioritäten. Den Rest fährt eine Schleife.

Das Team

Jede Rolle hat ein eigenes Mandat, eigene Grenzen und, wo es sich lohnt, ein eigenes Modell:

Rolle Wer Mandat Grenze
Stakeholder ich Ziel, Prioritäten, Freigabe der Stories kein Code, kein Micro-Management
Architekt Agent mit großem Modell aus der Story eine Spec mit testbaren Kriterien, Dateiliste und Verbotsliste schreibt keinen Code vor
Coder lokaler Coding-Agent auf dem Heimserver die eigentliche Arbeit, in einem abgeschotteten Verzeichnis nur unter den Guardrails
Prüfer Agent mit großem Modell Spec vor dem Lauf und Code nach dem Lauf gegen die Kriterien prüfen darf nur blockieren, nie freigeben
Gate Tests, Linter, SonarQube grün oder rot deterministisch, kein Modell

Das wichtigste Prinzip steht in der letzten Spalte: asymmetrische Autorität. Ein Modell darf Nein sagen, aber nie Ja. Ob etwas gemergt wird, entscheidet das Gate. Ein Modell, das „sieht gut aus“ sagt, beweist nichts. Ein roter Test schon.

Der Coder läuft lokal auf Zuse und kostet keine Tokens, nur Strom. Die großen Modelle für Architekt und Prüfer laufen mal lokal, mal über ein EU-Gateway — je nachdem, was die Grafikkarten gerade sonst tun.

Der Loop

Story im Ticket-System
  → Architekt: Spec mit testbaren Kriterien, Dateiliste, Verbotsliste
  → Spec-Prüfung: Ist die Story bereit? Sonst Halt mit Rückfrage
  → Coder im Käfig: eigener Branch, eigenes Verzeichnis, Zeitbudget
  → Gate: Tests, Linter, SonarQube
  → Review gegen die Kriterien: Veto oder nichts
  → bereit zum Merge

Zwei Regeln halten das zusammen.

Fragen statt raten. Ist etwas unklar, hält der Lauf an und stellt eine Frage. Ein Halt kostet mich eine Minute. Eine geratene Annahme, die drei Stories später auffällt, kostet einen Abend.

Der Coder sitzt im Käfig. Er sieht nur sein Arbeitsverzeichnis — kein /tmp, keine Zugangsdaten. Das kam nicht aus Prinzip, sondern aus Erfahrung: Ein früher Lauf schrieb ein Prüfskript nach /tmp, ein anderer hatte den Zugang zur Forge geerbt.

Gemergt wird heute noch von mir. Das Ziel ist „kein Merge ohne grünes Gate“ statt „kein Merge ohne Mensch“ — mein Gate wandert nach vorn, zur Freigabe der Story.

Loopwright Light: der Loop von Hand

Bevor die Maschine lief, gab es den Loop von Hand, und den gibt es noch: Issue, Feature-Branch, Spec mit testbaren Kriterien. Ein lokaler Coding-Agent setzt um, ein Architekt prüft den echten Diff gegen die Kriterien und fährt die Tests selbst, statt dem Bericht des Coders zu glauben. CI muss grün sein, gemergt wird von einem Menschen. So entstehen auch die Änderungen an dieser Website — dieser Artikel eingeschlossen.

Zahlen

476 gemergte Pull Requests seit dem ersten Merge am 31. Juli 2026 — gebaut im Loop, zuerst von Hand, zunehmend von Loopwright selbst.

Am 12. und 13. September hat Loopwright zum ersten Mal an sich selbst gearbeitet:

Lauf Dauer Ergebnis
1 40 min Timeout, rund 130.000 Token, danach keine Spur
2 31 min gleiche Spec, gleiches Modell: Pull Request, Gate grün
4 27 min erster Lauf im Käfig, erste Story ohne Handgriff bis zur Merge-Entscheidung
8 33 min Pull Request ohne einen einzigen Nachbesserungs-Commit
11 12 min dritte Story in Folge ohne Nachbesserung

In der Nacht zum 1. November liefen zweieinhalb Stories durch, mit etwa einem Eingriff pro Story. Aus diesen Eingriffen sind drei neue Stories im Backlog geworden.

Und die Kosten: Ende Oktober habe ich drei Tage lang am Gateway gemessen. 10,45 € für drei Tage, davon 52 % Code-Review, 37 % Spec-Prüfung, 9 % Architekt, 2 % Chat. Mein Bauchgefühl war „der Architekt ist teuer“. Falsch — die Prüfer sind es. Ein anderes Modell für die Review senkte den Preis von etwa 14 auf etwa 3 Cent pro Review.

Wo es auf die Nase gefallen ist

Grüne Tests, falsches Programm. Am 23. Oktober habe ich Loopwright gegen ein anderes Agenten-Framework antreten lassen, an einem kleinen Video-Werkzeug mit versteckten Abnahmetests. Die erste Aufgabe schafften beide, 6 von 6. Bei der zweiten lieferte Loopwright in elf Minuten Spec und Code, die Review hatte nichts einzuwenden, alle Tests waren grün — und mit echtem ffmpeg funktionierten 3 von 6 Fällen. Ein ungültiger Filterparameter, ein ignorierter Rückgabewert, Exit 0 ohne Bild. Die Tests liefen gegen ein nachgebautes ffmpeg, die CI hatte gar keins. Prüfungen, die nur die Form prüfen, beweisen nichts. „Abnahme durch echte Ausführung“ steht seitdem ganz oben im Backlog. Das andere Framework prüfte ehrlicher, scheiterte aber an anderer Stelle. Der Befund des Tages: Die Coder-Modelle waren gleichauf. Der Unterschied liegt in der Hülle.

Die Schlussprüfung, die nie endet. Ein Lauf war fertig, die Tests grün, 95,8 % Abdeckung. Der Coder startete seine „letzte Schlussprüfung“ trotzdem immer wieder neu, bis das Zeitbudget ablief. Seitdem steht ein Stopp-Kriterium im Auftrag, und bei einem Timeout wird der Zwischenstand gesichert.

Raten statt fragen. Eine Spec verlangte eine SSH-Adresse „in Kurzform mit Port“ — die Kurzform kennt gar keinen Port. Der Coder hat den Widerspruch bemerkt und dann eine Rate-Heuristik gebaut, statt anzuhalten. Die Ursache war die Spec, nicht das Modell.

Die Review verdient ihr Geld. Sie fand ein Passwort, das in einer Fehlermeldung landete — auf einem Fehlerpfad, den die Tests des Coders nicht abdeckten.

Ein Modell, zwei Coder. Zwei Läufe gleichzeitig auf demselben Modell endeten beide im Timeout, mit weniger als der Hälfte der Arbeit. Parallel spart keine Zeit, wenn die Grafikkarte der Engpass ist. Heute laufen höchstens zwei Coder gleichzeitig.

Wohin

Loopwright soll die Zentrale werden: ein Leitstand, in dem ich sehe, was läuft, mit Loopwright chatte und mit einem virtuellen Product Owner plane. Die Reihenfolge ist klar — erst Robustheit, dann Komfort. Echte Ausführung bei der Abnahme, Zeitgrenzen je Stufe, ein Lagebild, wenn etwas hängt.

Das Ziel ist nicht, dass Loopwright schneller tippt als ich. Das Ziel ist, dass meine Projekte fertig werden — und ich nur noch Chef und Visionär bin.

Welche Modelle dabei was leisten und wie ich das messe, steht im Messlabor.

Prompt engineering is dead. Long live loop engineering.

I have more unfinished projects than free evenings. Every single one would be done in two weeks — if I spent two weeks on it in one go. I don't. I spend twenty minutes, then the next context switch hits, and when I come back, the first half hour is searching: Where was I? What was the plan? Why is the test red?

Loopwright is my answer. Not an AI button bolted onto a ticket system, but the reverse: a ticket system worked through by a team of AI roles. I bring the goal and the priorities. A loop does the rest.

The team

Each role has its own mandate, its own limits and, where it pays off, its own model:

Role Who Mandate Limit
Stakeholder me goal, priorities, releasing stories no code, no micro-management
Architect agent with a large model turns a story into a spec with testable criteria, a file list and a do-not list doesn't dictate the code
Coder local coding agent on the home server the actual work, in a sandboxed directory only within the guardrails
Reviewer agent with a large model checks the spec before the run and the code after it against the criteria may only block, never approve
Gate tests, linter, SonarQube green or red deterministic, no model

The most important principle is in the last column: asymmetric authority. A model may say no, but never yes. Whether something gets merged is decided by the gate. A model saying “looks good” proves nothing. A red test does.

The coder runs locally on Zuse and costs no tokens, only electricity. The large models for architect and reviewer run sometimes locally, sometimes through an EU gateway — depending on what the graphics cards are busy with.

The loop

Story in the ticket system
  → Architect: spec with testable criteria, file list, do-not list
  → Spec check: is the story ready? Otherwise halt with a question
  → Coder in the cage: own branch, own directory, time budget
  → Gate: tests, linter, SonarQube
  → Review against the criteria: veto or nothing
  → ready to merge

Two rules hold it together.

Ask, don't guess. If something is unclear, the run halts and asks a question. A halt costs me a minute. A guessed assumption that surfaces three stories later costs an evening.

The coder sits in a cage. It sees only its working directory — no /tmp, no credentials. That didn't come from principle but from experience: an early run wrote a check script to /tmp, another one had inherited access to the forge.

For now, I still do the merging. The goal is “no merge without a green gate” instead of “no merge without a human” — my gate moves to the front, to releasing the story.

Loopwright Light: the loop by hand

Before the machine ran, there was the loop by hand, and it's still there: issue, feature branch, spec with testable criteria. A local coding agent implements, an architect checks the real diff against the criteria and runs the tests itself instead of believing the coder's report. CI has to be green, a human merges. That's how changes to this website are made too — this article included.

Numbers

476 merged pull requests since the first merge on 31 July 2026 — built in the loop, by hand at first, increasingly by Loopwright itself.

On 12 and 13 September, Loopwright worked on itself for the first time:

Run Duration Result
1 40 min timeout, around 130,000 tokens, then no trace
2 31 min same spec, same model: pull request, gate green
4 27 min first run in the cage, first story without a single manual step up to the merge decision
8 33 min pull request without a single fix-up commit
11 12 min third story in a row without fix-ups

In the night to 1 November, two and a half stories went through, with roughly one intervention per story. Those interventions have turned into three new stories in the backlog.

And the costs: at the end of October I measured at the gateway for three days. €10.45 for three days, of which 52% code review, 37% spec checking, 9% architect, 2% chat. My gut said “the architect is expensive.” Wrong — the reviewers are. A different model for the review cut the price from about 14 to about 3 cents per review.

Where it fell flat on its face

Green tests, wrong program. On 23 October I pitted Loopwright against another agent framework on a small video tool with hidden acceptance tests. Both passed the first task, 6 out of 6. On the second, Loopwright delivered spec and code in eleven minutes, the review had no objections, all tests were green — and with real ffmpeg, 3 out of 6 cases worked. An invalid filter parameter, an ignored return value, exit 0 without an image. The tests ran against a fake ffmpeg, and CI had none at all. Checks that only check the form prove nothing. “Acceptance through real execution” has been at the top of the backlog ever since. The other framework checked more honestly but failed elsewhere. The finding of the day: the coder models were on par. The difference is in the shell around them.

The final check that never ends. One run was done, tests green, 95.8% coverage. The coder still kept restarting its “last final check” until the time budget ran out. Since then, the task contains a stop criterion, and on a timeout the intermediate state is saved.

Guessing instead of asking. A spec asked for an SSH address “in short form with a port” — the short form has no port. The coder noticed the contradiction and then built a guessing heuristic instead of halting. The cause was the spec, not the model.

The review earns its keep. It found a password ending up in an error message — on an error path the coder's tests didn't cover.

One model, two coders. Two runs at the same time on the same model both ended in a timeout, with less than half of the work done. Parallel doesn't save time when the graphics card is the bottleneck. Today, at most two coders run at once.

Where it's going

Loopwright is meant to become the hub: a control room where I see what's running, chat with Loopwright and plan with a virtual product owner. The order is clear — robustness first, comfort second. Real execution in acceptance, time limits per stage, a situation report when something hangs.

The goal isn't for Loopwright to type faster than me. The goal is for my projects to get finished — with me just being the boss and the visionary.

Which models deliver what along the way, and how I measure it, is in the Measurement Lab.