The build loopPart 1 of 1

In Etappen bauen: auf einen nutzbaren Kern zuschneiden, jeden Schritt prüfen, die Arbeit zeigen

Ein KI-Agent baut eine App in einem einzigen Durchlauf – planen, schreiben, verdrahten, am Ende prüfen. Für eine kleine App ist das die richtige Form; für eine ambitionierte ist sie undurchsichtig, ein Alles-oder-nichts-Spiel und über einen langen Horizont anfällig für Drift. Drei Designentscheidungen ändern das: Der Planer schneidet die Anfrage auf einen nutzbaren v1-Kern zu und legt den Rest in einem nachverfolgten Backlog ab; jeder Schritt verdient sich sein „fertig“ durch objektive Checks – eine Contract-Probe gegen die laufende App, die eigenen Tests des Projekts im Pod, ein Regressionslauf der gesamten Suite gegen die Baseline vom Start des Laufs und ein Readiness-Gate vor Prod; und jede Phase streamt in einen Activity-Feed, sodass ein minutenlanger Lauf nachvollziehbar bleibt. Hier die Pipeline und wie sie im Detail funktioniert.

In Etappen bauen: auf einen nutzbaren Kern zuschneiden, jeden Schritt prüfen, die Arbeit zeigen

Ein KI-Agent baut eine App in einem einzigen Durchlauf. Er bekommt einen Plan, ein großes Kontextfenster und eine Reihe von Tools – und läuft, bis er selbst entscheidet, dass er fertig ist: Er schreibt Dateien, führt SQL aus, verdrahtet Router und prüft ganz am Ende.

Für eine kleine App ist ein Durchlauf genau die richtige Form. Für eine ambitionierte – ein LMS, einen Marktplatz, ein Projektmanagement-Tool – hat ein langer, undifferenzierter Durchlauf drei Eigenschaften, die nicht skalieren:

  • Er ist undurchsichtig. Ein Lade-Spinner kann einen gesunden Build von fünfzehn Minuten nicht von einem hängenden unterscheiden. Es gibt keine Meilensteine zu melden, weil der Lauf keine hat.
  • Er ist ein Alles-oder-nichts-Spiel. Scheitert er nach drei Vierteln, bleibt nichts, was du öffnen kannst – keine kleinere App, sondern eine leere.
  • Er driftet über einen langen Horizont. Ein größeres Kontextfenster verbessert vor allem das Retrieval – das Modell sieht mehr von der Codebasis –, nicht den Ausführungshorizont, also die Zahl korrekter Schritte, die es aneinanderreihen kann, bevor es den Faden verliert. Wird die Prüfung bis zum Ende aufgeschoben, fängt nichts die Drift ab, solange sie noch billig zu beheben ist.

Die robuste Antwort ist nicht ein größeres Kontextfenster – das hieße, alles darauf zu setzen, dass der Ausführungshorizont nie nachlässt –, sondern eine andere Form der Arbeit: den Build auf einen nutzbaren Kern zuschneiden, jeden Schritt prüfen, sobald er steht, und den Lauf erzählen, damit er nachvollziehbar bleibt. Drei Ideen, je ein Abschnitt.


Zuschneiden: ein nutzbarer Kern, dann ein nachverfolgter Backlog

Wenn eine Anfrage groß ist, versucht der Planer nicht, alles in einen einzigen Build zu packen. Er entwirft einen v1-Kern – die kleinste Version, die wirklich nutzbar ist – und hält den Rest als strukturierten deferredStages-Backlog am Plan fest – nicht als Prosa, die er wieder vergisst.

Das hat einen unmittelbaren und einen strukturellen Effekt.

Der unmittelbare Effekt ist der, den du siehst: eine Preview, die du innerhalb von Minuten öffnen, durchklicken und benutzen kannst, statt eines einzigen riesigen Builds, der nichts wert ist, bis er komplett fertig ist. Dank des Backlogs kann die App dir, sobald deine v1 läuft, anbieten, die nächste Etappe zu bauen – auf der Plan-Seite als Upcoming stages und unter dem Chat als anstehende Phasen. Sag „ja“ oder nenne eine Etappe im Chat (im Web oder in Telegram), und die App baut diese Etappe auf dem auf, was du schon hast.

bank the rest

accept → build next stage

fork forward

ambitious request

plan: scope v1 core
+ deferredStages backlog

build v1 core

running preview
committed · on a CoW branch

deferred stages

build stage 2

Der strukturelle Effekt ist subtiler und zielt direkt auf das Problem des langen Horizonts. Ein v1-Kern ist ein kürzerer Plan, und ein kürzerer Plan ist ein kürzerer Ausführungshorizont – weniger Strecke, auf der der Agent driften kann, bevor ein funktionierendes, prüfbares Ergebnis steht. Zuschneiden ist nicht nur UX-Kosmetik; es ist der billigste Weg, den Lauf in dem Bereich zu halten, in dem das Modell kohärent bleibt. Auf einen engeren Umfang zu setzen ist auf Dauer die bessere Wette als auf mehr Kontext.

In Etappen zu erweitern ist sicher, weil jede Version ein echter, wiederherstellbarer Punkt ist. Jede Generierung wird von commitGeneration in die Git-Historie des Projekts committet, und die Datenbank jedes Projekts ist eine Copy-on-Write-Timeline – „deine App nach v1“ ist also ein dauerhafter Snapshot von Code und Daten. Die nächste Etappe zu bauen ist keine In-place-Änderung, die du nicht rückgängig machen kannst, sondern ein Schritt nach vorn von einer Version, zu der du jederzeit zurückkehren kannst.


Prüfen: jeder Schritt verdient sich sein „fertig“

Ein engerer Zuschnitt hilft nur, wenn jeder Schritt tatsächlich geprüft wird; sonst kommt die Drift nur früher. Deshalb wartet die Prüfung nicht bis zum Ende des Builds – sie läuft bei jedem Schritt, gegen das laufende System.

Jedes Projekt wird testbar geboren. Die Scaffold-Templates bringen einen Test-Runner und eine browserähnliche Umgebung schon fertig verdrahtet mit – vitest, jsdom, @testing-library –, eingebacken ins Basis-Image. Tests lassen sich ab dem ersten Schritt schreiben und ausführen, im echten App-Pod, nie in einer Simulation.

Während der Build voranschreitet, wird jede Subtask von verify-pipeline.js aus dem Verification-Block beurteilt, bevor sie als erledigt markiert werden kann. Die Pipeline durchläuft eine Reihe objektiver Schichten – Typ- und Import-Checks, generierte Flow-Tests gegen die Live-Datenbank, einen Headless-Besuch der Seite und mehr –, aber zwei davon tragen die Hauptlast, und beide prüfen die deployte App statt eines Mocks:

  • Eine Contract-Probe trifft die laufende App. Wenn eine Subtask eine API-Route hinzufügt, ruft contract-tests.js den laufenden Pod über seinen eigenen Dev-Server auf (die tRPC-Prozeduren werden über den Vite-Proxy auf Port 3000 erreicht): Antworten die deklarierten Prozeduren ohne 500er oder Zod-Fehler, und existieren die Tabellen, von denen sie abhängen? Wenn der Plan eine Prozedur verlangt hat und sie nicht wirklich da ist, schlägt das fehl – objektiv, nicht nach der Meinung eines LLM.
  • Die eigenen Tests der App laufen im Pod. project-tests.js führt die vitest-Suite des Projekts im Container aus, und eine Subtask, die einen Router schreibt, wird erst freigegeben, wenn ein bestandener Test ihn abdeckt – einen eigenen oder einen Flow-Test, den die Plattform gegen die Live-Datenbank generiert.
app pod (live)verify-pipelineproducer (agent)app pod (live)verify-pipelineproducer (agent)"done" is earned by a check that ran — not a file on disksubtask complete? (todo_write)contract probe · :3000 (procedures respond · tables exist)npm test (the app's own unit tests, in-pod)resultspassing · or reopened (fix, then re-check)

Der Producer führt diese Checks auch selbst mitten in der Arbeit aus, über run_acceptance_check, bevor er eine Subtask für fertig erklärt – das Gate am Ende eines Schritts ist also keine Überraschung, sondern dieselbe objektive Messlatte, an der sich der Agent die ganze Zeit misst. „Passing“ verdient sich durch einen Check, der wirklich gelaufen ist, nie dadurch, dass eine Datei auf der Platte liegt. Um genau diesen Unterschied geht es: Die Lücke zwischen „der Code ist da“ und „der Code funktioniert“ ist die Lücke zwischen einer Demo und einem Produkt.

Weil mit der App auch ihre Tests wachsen, führt jeder Schritt außerdem die gesamte Suite erneut aus und vergleicht die Fehlschläge mit einer Baseline vom Start des Laufs: Ein Test, der vorher bestanden hat und jetzt fehlschlägt, öffnet den Schritt wieder, der ihn kaputt gemacht hat. Eine neue Etappe kann also nicht unbemerkt kaputt machen, was eine frühere bereits richtig hatte. Vor Prod steht noch ein objektives Gate – checkDeployReadiness lehnt einen Release ab, dessen Schritte fehlschlagen oder überwiegend ungeprüft sind oder dessen Dev-App nicht antwortet –, und keines dieser Urteile stammt von einem Modell, das seine eigene Arbeit benotet.


Erzählen: der Build berichtet, während er läuft

Ein Build mit echten, prüfbaren Schritten kann wahrheitsgemäß über sich berichten, also wird der Lauf gestreamt statt versteckt. Jede Phase schickt typisierte Events in einen Activity-Stream (blocks/events/adapters/activity.js) – Server-Sent Events an die Web-App, weitergereicht an Telegram –, gruppiert in die Phasen, die du während der Arbeit siehst:

  • Planung – deine Idee analysieren, Features skizzieren, den Build-Plan schreiben. Das sind die echten Schritte des Planers, gestreamt, während der Plan entsteht.
  • Bauen – die Arbeit meldet sich, während sie passiert; geschriebene Dateien und SQL-Läufe werden unter dem aktiven Schritt mit laufendem Zähler gruppiert.
  • Abschluss – den Build prüfen, deployen, alles hochfahren. Die Finalisierungsphase ist eine Folge echter Operationen – der Release-Check und das Hochfahren der App –, also erzählt sie jede davon, statt zu verstummen.

Ein Detail zählt mehr, als seine Größe vermuten lässt. Der „schreibt…“-Indikator von Telegram erlischt nach etwa fünf Sekunden, aber einen Plan für eine echte App zu erstellen dauert ein bis drei Minuten. Deshalb sendet der Bot das Signal während einer langen Antwortrunde in kurzen Abständen erneut und schickt einmal eine kurze „arbeite noch“-Nachricht (blocks/channels/application/telegram/bot.js) – ein bewusstes Keepalive, damit eine langsame Antwort nicht so wirkt, als wäre der Bot tot. Der Sinn dieser ganzen Schicht ist kein Fortschrittsbalken; er liegt darin, dass jede Zeile etwas entspricht, das wirklich passiert ist.


Was du davon hast

  • Schnell eine nutzbare App. Eine ambitionierte Anfrage kommt als funktionierender Kern plus nachverfolgtem Backlog zurück, nicht als eine einzige Wette auf später – es gibt immer etwas zu öffnen.
  • Wiederherstellbare Versionen. Jede Generierung ist ein Git-Commit auf einem Copy-on-Write-Datenbank-Branch; deine App wächst also von einem Snapshot aus weiter, zu dem du per Rollback zurückkannst – Code und Daten zusammen.
  • Geprüft, nicht behauptet. Objektive Checks laufen bei jedem Schritt, die gesamte Suite schützt frühere Etappen, und vor Prod steht ein Readiness-Gate; „fertig“ heißt, dass eine Contract-Probe und die eigenen Tests der App bestanden haben, nicht, dass eine Datei geschrieben wurde.
  • Ein nachvollziehbarer Lauf. Der Build streamt seine echten Phasen, sodass du einem minutenlangen Agentenlauf zusehen kannst, statt nur zu warten.
  • Von Grund auf modellunabhängig. Nichts davon hängt davon ab, dass sich der Ausführungshorizont verbessert. Ein besseres Modell schafft einfach mehr innerhalb derselben disziplinierten Form – zugeschnittene Arbeit, geprüfte Schritte –, sodass schon eine einzige Regression die Plattform nie in stille, ungeprüfte Drift kippen lassen kann.

Die Form im Ganzen

Hör auf, einen Build als einmaligen Vertrauensvorschuss zu sehen, der entweder aufgeht oder nicht, und sieh ihn als Folge zugeschnittener, geprüfter, erzählter Schritte. Zuschneiden macht aus einer ambitionierten Anfrage einen nutzbaren Kern mit kürzerem Horizont; objektive Prüfung macht aus „der Agent sagt, er ist fertig“ ein „die laufende App hat die Checks bestanden“; Erzählen macht aus undurchsichtigem Warten einen nachvollziehbaren Lauf. Diese Arbeit hat der Build schon immer geleistet – neu ist, dass sie jetzt begrenzt, geprüft und sichtbar ist, während sie passiert.

Bau auf der Plattform, die diese Beiträge beschreiben.

Beschreib deine App in einfachem Deutsch — igentik schreibt den Code, richtet die Datenbank ein und bringt sie live.

Kostenlos loslegen