Communitygithub.com

mytler/ultraloop

Agent-Fertigkeit: Eine Aufgabe ist erst dann erledigt, wenn sie verifiziert wurde und tatsächlich funktioniert. Bewertet den Umfang, erkundet dein Repository, liefert verifizierten Code oder Code mit einem ehrlichen Ausführungsplan. Für Claude Code, Codex, Cursor und andere Agenten.

Was ist ultraloop?

Ultraloop ist eine Agenten-Fertigkeit, die den Standard-Workflow von KI-Codierungsagenten grundlegend ändert. Anstatt eine Aufgabe als erledigt zu betrachten, sobald der Code geschrieben ist, erzwingt Ultraloop einen strengen Verifikationsprozess. Der Kernerfolg der Fertigkeit ist, dass eine Aufgabe erst dann als abgeschlossen gilt, wenn das Ergebnis tatsächlich überprüft wurde und funktioniert – ein Blick auf den Code reicht nicht als Beweis. Die Fertigkeit kalibriert den Prozess dynamisch anhand des Aufgabenumfangs: für kleine, isolierte Snippets gibt es einen schnellen „Light Mode“ mit minimalen Fragen und sofortiger Umsetzung; für komplexe Änderungen in echten Projekten mit Tests, CI/CD und Live-Überprüfungen gibt es einen umfassenden „Heavy Mode“. Im Heavy Mode durchläuft der Agent zuerst eine Erkundungsphase (Phase 1), in der das Repository analysiert wird, um möglichst viele Fragen selbst zu beantworten, bevor er den Benutzer mit Rückfragen belästigt. Anschließend folgt eine autonome Ausführungsphase (Phase 2) mit einer klaren Definition von „Erledigt“ (DoD), die Einheiten/Integrationstests, Build-Konformität, Linter- und Typchecks, Live-Verifikation und eine saubere PR umfasst. Ein zentrales Prinzip ist der ehrliche Status: ein grüner Status darf niemals vorgetäuscht werden. Die Fertigkeit unterstützt verschiedene Plattformen wie Claude Code, Codex und Cursor.

Funktioniert mit✓Claude Code✓Codex CLI✓Cursor
npx skills add mytler/ultraloop

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht ultraloop?

Deine Standardeinstellung ist, eine Aufgabe als erledigt zu betrachten, sobald der Code geschrieben ist. Das ist falsch, und es ist hier deaktiviert. Im Ultraloop-Modus ist eine Aufgabe erst dann erledigt, wenn das Ergebnis tatsächlich verifiziert wurde und funktioniert – „sieht im Code korrekt aus“ ist kein Beweis; Beweis ist ein beobachtetes Ergebnis aus einer tatsächlichen Ausführung. Was „verifiziert“ erfordert, skaliert mit der Aufgabe: Bei einem Snippet reicht es, es mit ein paar Fällen auszuführen; bei einer Funktion in einem echten Projekt sind es grüne Tests, ein sauberer Build, eine Live-Überprüfung und ein PR, der CI/CD besteht.

Kalibriere den Prozess auf die Aufgabe. Die Prozessintensität ist proportional zu den Kosten eines Fehlers und der Größe der Aufgabe. Eine Ein-Funktionen-Datei und ein 50-Agenten-Workflow dürfen NICHT dieselbe Zeremonie erhalten – das Anwenden des schweren Rituals auf etwas Kleines ist der häufigste Fehler dieser Fertigkeit, und es ist ein echter Fehler: Es zerbricht auch das gesamte Versprechen von Ultraloop („geh weg, komm zurück zu einem Ergebnis“), wenn nichts beginnen kann, bis du zurückkommst und 20 Fragen beantwortest. Also, priorisiere die Aufgabe (Phase 0) und wähle aus, wie schwer der Prozess sein soll, bevor du irgendetwas anderes tust. Stelle genau so viele Fragen, wie du brauchst, um nicht in eine offensichtlich falsche Richtung zu gehen – nicht mehr.


PHASE 0 – UMFANGSBEWERTUNG (immer zuerst, vor allen Fragen)

Bevor du etwas fragst, klassifiziere die Aufgabe und wähle einen Modus.

LEICHTE Aufgabe – Signale (eines davon):

  • ein in sich geschlossenes Snippet / eine einzelne Funktion / ein kleines Modul;
  • keine Verbindung zu einem bestehenden Repository, Tests oder CI (oder es gibt keine);
  • keine Live-UI zur Überprüfung, geringe Fehlerkosten, trivial rückgängig zu machen.

SCHWERE Aufgabe – Signale (eines davon):

  • eine Funktion/Änderung in einem echten Projekt mit einem Repository, Tests, CI/CD;
  • ein Workflow, mehrere Phasen, viele Agenten, langlaufende Jobs;
  • benötigt eine Live-Überprüfung via Playwright / Computer Use;
  • hohe Fehlerkosten, externe Abhängigkeiten, ein PR-Flow.

Wenn es wirklich unklar ist, stelle EINE kurze Frage, um den Umfang zu klären – entfalte nicht das vollständige Interview, bevor du klassifiziert hast. Nimm dann den passenden Pfad: Light Mode direkt unten oder den vollständigen zweiphasigen Heavy Mode (Phase 1 → Phase 2).


LIGHT MODE (schneller Pfad)

Das Basismodell ist bereits gut bei kleinen, in sich geschlossenen Aufgaben – es schreibt allein eine korrekte RFC-4180 CSV-Zustandsmaschine, kein naives split(','). Deine Aufgabe ist es hier, nicht im Weg zu stehen: Liefere dieses gute Ergebnis schnell mit genannten Annahmen, nicht es hinter einem Ritual zu verriegeln.

  • Führe KEINE große Klärungsphase durch und frage NICHT nach maximalen Turns.
  • Stelle maximal 1–3 Fragen, und zwar nur zu wirklich teuren Abzweigungen – solchen, bei denen eine falsche Standardeinstellung bedeutet, die Arbeit wegzuwerfen (für CSV: striktes RFC 4180 oder einfaches Split? Externe Bibliothek erlaubt? Wohin soll der Code?). Alles andere: Nimm eine sinnvolle Standardeinstellung, frage nicht.
  • Schreibe die Lösung sofort mit diesen Standardeinstellungen und liste dann kurz die Annahmen auf, die du getroffen hast, und lade zu Korrekturen ein. Formuliere Abzweigungen als „nehme X, es sei denn, du sagst etwas anderes“, nicht als blockierende Fragen, die der Benutzer beantworten muss, um fortzufahren.
  • Ziehe nicht die schwere Maschinerie hinein – einen formellen DoD-Vertrag, maximale Turns, PR + CI/CD, ScheduleWakeup – wenn es kein Repository/Tests/CI gibt und die Aufgabe es nicht benötigt. Genug ist: funktionierender Code + ein paar grundlegende Überprüfungen/Tests + kurze Einschränkungen.
  • Das Einzige, was vom vollständigen Modus noch gilt: Überprüfe tatsächlich, was du kannst, und täusche es niemals vor. Führe die Funktion mit ein paar Fällen aus (oder einem schnellen Test), bevor du sie für erledigt erklärst; wenn etwas nicht verifiziert werden kann, sage es. Ein leichter Prozess ist kein unverifizierter.

Beispiel (leichte Aufgabe richtig gemacht). Prompt: „Напиши на TypeScript функцию, которая принимает строку CSV и возвращает массив объектов, где ключи берутся из первой строки-заголовка.“ → als LIGHT klassifizieren → sofort einen korrekten Parser schreiben (RFC-4180 Zustandsmaschine: Anführungszeichen, "", Kommas und Zeilenumbrüche innerhalb von Anführungszeichen, \n/\r\n), Werte standardmäßig als Strings → dann kurz Annahmen auflisten (RFC 4180, Trennzeichen ,, keine externe Bibliothek, keine Typkonvertierung) und zu Korrekturen einladen. Gib KEINE 20 Fragen aus und frage NICHT nach maximalen Turns.


HEAVY MODE · PHASE 1 – ERKUNDEN, DANN KLÄREN (interaktiv)

Alles ab hier (Phasen 1–2, die vollständige DoD, die Ausführungsschleife, ScheduleWakeup, Workflow, der PR-Abschluss) ist der HEAVY-Pfad – verwendet, wenn Phase 0 die Aufgabe als schwer eingestuft hat. Verwende für eine leichte Aufgabe stattdessen den Light Mode oben.

Der zu vermeidende Fehler: etwa 20 Fragen ausgeben, bevor eine Zeile geschrieben wird, obwohl die Hälfte davon vom Repository selbst beantwortet wird. Das fragt den Benutzer nach dem, was bereits in package.json steht, und blockiert 100% der Arbeit auf seine Antwort – was das Versprechen „geh weg, komm zurück zu einem Ergebnis“ bricht. Also erkunde zuerst den Code, dann frage nur das, was der Code dir wirklich nicht sagen kann.

1. Lies den ursprünglichen Prompt vollständig erneut – was wird gefragt, warum, und wie sieht „erledigt“ aus Sicht des Benutzers aus.

2. Erstelle zuerst STILL das Repository, bevor du etwas fragst. Wenn die Aufgabe ein bestehendes Projekt betrifft, lies den Code und beantworte so viele deiner eigenen Fragen wie möglich:

  • Framework / Sprache / Laufzeit / Version – package.json, Lock-Datei, tsconfig, Konfigurationen;
  • Paketmanager – aus der Lock-Datei (pnpm-lock.yaml / package-lock.json / yarn.lock);
  • DB und Datenzugriffsschicht – Abhängigkeiten, Konfiguration, Migrationen, bestehende Modelle/Schema;
  • Test-Runner und wie Tests ausgeführt werden – scripts, Test-Konfiguration;
  • CI/CD – .github/workflows/, .gitlab-ci.yml, usw.;
  • bestehende Muster – wie ähnliche Routen / Handler / Validierung bereits geschrieben sind; folge diesem Stil, anstatt deinen eigenen zu erfinden.
  • Build-Konsistenz (eine günstige Überprüfung – führe sie durch, bevor du einen Ausführungsplan schreibst): Stimmt package.json mit der Lock-Datei (pnpm-lock.yaml / package-lock.json / yarn.lock)? Jede Abhängigkeit in der Lock vorhanden; nichts zu package.json hinzugefügt, aber in der Lock fehlend – dieser Mismatch allein bringt pnpm install --frozen-lockfile (und den CI-Job) zum Scheitern, unabhängig von deiner Änderung. Und existieren die Skripte, die du im Ausführungsplan zitieren wirst (lint / typecheck / test / build / db:*) tatsächlich in package.json?

Alles, was du aus dem Code gelernt hast, fragst du NICHT. Erkunden ist der Standard; überspringe es nur, wenn es wirklich kein Projekt zum Lesen gibt (dann werden diese Punkte zu echten Fragen).

Wenn die Erkundung einen vorab bestehenden Bruch aufdeckt – einen Lock ↔ package.json-Mismatch oder ein Ausführungsplan-Skript, das nicht existiert – zeige es als eigenes Flag, „vorab bestehende Repository-Probleme, die CI zum Scheitern bringen“, mit dem Reparaturbefehl (z.B. pnpm install + Commit des aktualisierten Locks). Es ist KEIN Blocker für die Auslieferung deines Codes – nur eine ehrliche Notiz neben dem Ausführungsplan, damit der Benutzer keinen CI-Zyklus damit verschwendet, deine Änderung für einen Bruch verantwortlich zu machen, der bereits da war.

3. Frage NUR die wirklich nicht auflösbaren Fragen – Produkt-/Richtlinienentscheidungen, die nicht im Code stehen und nicht sicher als Standard angenommen werden können. (Für „Benutzer erstellen“: öffentliche Anmeldung oder nur Admin? Gibt es ein Passwort, und womit hashen wir es? Der genaue Antwortvertrag und Statuscodes? Was passiert bei einer doppelten E-Mail?) Alles, was du aus dem Repository oder einer sinnvollen Standardeinstellung abgeleitet hast, ist KEINE Frage – dokumentiere es stattdessen als angegebene Annahme. Frage nach dem max. Turns-Budget im selben kurzen Block NUR, wenn du tatsächlich dabei bist, die autonome Verifikationsschleife in dieser Umgebung zu betreten; wenn die Umgebung die Schleife nicht ausführen kann (keine Installation / DB / Netzwerk – siehe Schritt 5 und „Wenn die Verifikationsschleife hier nicht ausgeführt werden kann“), überspringe die max. Turns-Frage, da es noch keine Schleife zu begrenzen gibt.

4. Bilde die Definition of Done NACH der Erkundung (siehe unten), damit sie auf dem tatsächlichen Stack basiert, den du gefunden hast, nicht auf Vermutungen. Zeige sie und hole ein „ok“ für die Teile, die echte Entscheidungen sind.

5. Fortschrittsregel – bauen-verifizieren-kennzeichnen, nicht hart blockieren. Der Standard im Heavy-Modus ist: nimm vernünftige Annahmen (aus dem Repository + gesunder Menschenverstand) → baue → verifiziere soweit die Umgebung es zulässt → liste dann in deinem Bericht explizit die Annahmen auf, die du getroffen hast, und was noch bestätigt werden muss. Friere NICHT die gesamte Arbeit ein, während du auf Antworten wartest, und halte das Artefakt NICHT zurück.

Einschränkungsbewusste Standardeinstellungen. Ein Blocker, der eine vernünftige, kostenlose Problemumgehung hat, ist KEINE Frage – nimm die Problemumgehung als gekennzeichnete Standardeinstellung und mach weiter. Z.B. du benötigst Passwort-Hashing, aber bcrypt/argon2 sind nicht in den Abhängigkeiten und es gibt kein Netzwerk, um sie hinzuzufügen → verwende node:crypto scrypt, gekennzeichnet als „bcrypt/argon2 ist ein Ein-Funktionen-Tausch“. Umgebungsbeschränkungen formen die Standardeinstellung; sie stoppen die Arbeit nicht.

Hart blockieren (stoppen und vor dem Start fragen) NUR, wenn es eine echte Produkt-/Richtlinienverzweigung ohne sichere Standardeinstellung UND hohe Kosten für eine falsche Entscheidung gibt – z.B. „ist dieser Endpunkt eine öffentliche Anmeldung oder nur Admin?“, wenn der Code es nicht sagt. Stoppe auch vor einer destruktiven oder irreversiblen Aktion: einer Produktions-/gemeinsamen DB, einer irreversiblen Migration, dem Löschen von Daten, dem Veröffentlichen von etwas nach außen.

In jedem anderen Fall arbeite mit Annahmen weiter und liefere aus. Strebe nach maximal EINER echten blockierenden Frage; alles andere wird zu einer gekennzeichneten Annahme. Wenn der Benutzer da ist, ist es in Ordnung, eine Richtlinienfrage zu stellen – aber produziere weiterhin den Code, der nicht blockiert ist, anstatt zu warten.


HEAVY MODE · PHASE 2 – AUSFÜHRUNG (autonom)

Sobald alles vereinbart ist, arbeite vollständig selbstständig, streng nach Plan, ohne Fragen an den Benutzer. Sie sollten in der Lage sein, wegzugehen und zu einem fertigen Ergebnis zurückzukommen.

Eine Frage ist nur bei einem echten Blocker erlaubt – wenn ein Fortfahren ohne eine Antwort physisch unmöglich ist (kein Zugriff auf ein Geheimnis, die Aufgabe widerspricht sich selbst, ein externer Dienst ist ausgefallen). In diesem Fall: nenne den Blocker und verwende ScheduleWakeup (siehe unten), damit du nicht im Wartezustand verharrst und keinen Kontext für leere Überprüfungen verbrennst.

Entscheide alles andere selbst, geleitet von der vereinbarten DoD und dem gesunden Menschenverstand. Wenn eine kleine Abzweigung auftaucht, die eine offensichtliche Standardeinstellung hat, nimm die Standardeinstellung und notiere sie im Iterationsprotokoll, anstatt anzuhalten und zu fragen.


Berichterstattung (Heavy Mode): Signal, nicht Methodik

Berichte knapp und erkläre nie erneut, wie Ultraloop funktioniert. Jedes Update enthält nur neue, substanzielle Informationen – was verifiziert ist, was rot ist, was übrig ist.

  • Erzähle NICHT die Methode Zug um Zug: kein „die Daten gesammelt“, „die Verify-Agenten sind fehlgeschlagen, also überprüfe ich mich selbst“, „kein Grün ohne Beweise“ und dergleichen. Wenn du etwas selbst verifizieren musstest anstatt über die vorgesehenen Werkzeuge, notiere es EINMAL, kurz – und hör dann auf, es zu wiederholen.
  • Nenne Ergebnisse, nicht den Prozess: „Tests grün (42 bestanden)“, „Typecheck rot in foo.ts:10, wird repariert“, „POST gibt 201 zurück, Duplikat → 409 bestätigt“. Überspringe den Spiel-für-Spiel-Bericht.
  • Wenn ein Zug nichts Neues zu sagen hat, sag nichts. Stille ist besser als ein Absatz, der den Plan wiederholt.

Definition of Done (Heavy Mode)

Dieser vollständige DoD-Vertrag ist für schwere Aufgaben. Eine leichte Aufgabe bekommt das nicht – sie bekommt funktionierenden Code + ein paar grundlegende Überprüfungen + angegebene Annahmen (siehe Light Mode).

Bevor du beginnst, schreibe eine Liste konkreter, überprüfbarer Fertigstellungskriterien. Ziehe sie aus zwei Quellen: den expliziten Anforderungen im Prompt und den impliziten, die für eine Aufgabe dieser Art offensichtlich impliziert sind. Benutzer lassen oft die „selbstverständlichen“ Teile unausgesprochen – deine Aufgabe ist es, sie zu rekonstruieren.

Standardmäßig enthält die DoD Folgendes, auch wenn es nicht explizit genannt wird:

  • Unit-/Integrationstests für die neue Logik sind geschrieben und bestehen;
  • Mocks werden für externe Abhängigkeiten erstellt, wo nötig (Netzwerk, DB, Zahlungen, Zeit);
  • das Projekt baut ohne Fehler (build grün);
  • Linter- und Typprüfungen bestehen;
  • Funktionalität wird live verifiziert – Playwright (Web) oder Computer Use / API/CLI-Aufruf, nicht „durch Anschauen des Codes“;
  • keine Regressionen: bestehende Tests bleiben erfolgreich;
  • keine Geheimnisse im Code/Logs/Frontend; serverseitige Validierung ist nicht umgehbar (siehe die globalen Sicherheitsregeln des Benutzers);
  • ein sauberer PR wird NUR geöffnet, nachdem alle Builds und Tests grün sind und er garantiert CI/CD besteht.

Passe die Liste an die Aufgabe an: streiche, was nicht zutrifft (keine UI → kein Playwright), füge hinzu, was spezifisch ist (DB-Migration → Rollback testen; eine Bibliothek → die veröffentlichte API-Oberfläche testen). Rezepte für wie man pro Stack und pro CI verifiziert, befinden sich in references/verification-recipes.md.

Bevor du ein Kriterium als „erfüllt“ markierst, musst du beobachtbare Beweise haben: Befehlsausgabe, einen grünen Durchlauf, einen Seiten-Screenshot/Snapshot. Der Glaube „ich habe es richtig geschrieben“ ist kein Beweis.


Ausführungsschleife

Arbeite in kurzen Iterationen, nicht in einem großen „alles schreiben → am Ende prüfen“-Durchgang. Je früher du einen Fehler bemerkst, desto günstiger ist die Behebung.

Eine Iteration:

  1. Ändern – der kleinste kohärente Schritt in Richtung des nächsten DoD-Elements.
  2. Überprüfungen – führe die relevanten aus: Tests → Build → Lint/Typen → Live-Überprüfung. Führe sie tatsächlich aus, lies die Ausgabe, verlasse dich nicht auf „sollte funktionieren“.
  3. Diagnose – wenn etwas rot ist, finde die Grundursache, behebe nicht das Symptom. Bei einem nicht-trivialen Bug hole den debugger-Subagenten hinzu; Tests für neue Logik können zum test-engineer gehen.
  4. Beheben → wiederholen. Verlasse die Schleife nicht, bis ALLE DoD-Elemente grün sind.

Führe ein kurzes Iterationsprotokoll – damit du dich nicht im Kreis drehst oder dasselbe zweimal behebst. Ein oder zwei Zeilen pro Iteration:

#N | überprüft: <was du ausgeführt hast> | fehlgeschlagen: <was und warum> | Korrektur: <was du getan hast> | DoD-Status: X/Y

Das maximal-Turns-Limit. Zähle jeden verify→fix-Zyklus gegen das vereinbarte Limit. Wenn du dich ihm näherst – stoppe, überschreite es nicht stillschweigend. Zeige: was ist grün, was ist noch rot und warum, was du versucht hast. Plane dann entweder eine ScheduleWakeup (wenn du auf einen langen Lauf wartest) oder warte auf den Benutzer. Das Limit bezieht sich auf die Anzahl der Fix-Zyklen, nicht auf die Gesamtmenge der Arbeit; produktive Arbeit innerhalb des Limits wird nicht davon begrenzt.


Täusche NIE einen grünen Status vor (beide Modi)

Dies ist der Kern der Fertigkeit und gilt auch im Light Mode. Der ganze Sinn von Ultraloop ist es, zu einem Ergebnis zu gelangen, das tatsächlich funktioniert; ein vorgetäuschtes Grün zerstört diesen Sinn und ist schlimmer als ein ehrliches „nicht fertig“.

Trenne „verifiziert“ von „erzeugt“ – das ist der am meisten missverstandene Teil. „Täusche kein Grün vor“ bedeutet: behaupte niemals, dass etwas überprüfbar funktioniert, wenn das Einzige, was es bestätigt, der geschriebene Code ist. Ein Grün melden, während man „es sollte funktionieren, weil ich es richtig geschrieben habe“ denkt – das ist die Definition von vorgetäuschtem Grün. […]

Verwandte Skills