KI-Studiengang Loop Engineering
Hör auf, deinen Coding-Agenten an der Hand zu führen. Bau Loops, die sich selbst korrigieren, ihre eigene Ausgabe prüfen, rechtzeitig stoppen und unbeaufsichtigt laufen — ohne Tokens zu verbrennen.
Why This Instead of a Traditional Degree?
Den Agenten von Hand prompten
- Du sitzt daneben, beobachtest den Agenten und promptest ihn jedes Mal neu, wenn er hängenbleibt
- Er stoppt einen Schritt zu früh — oder läuft 40 Schritte über das Ziel hinaus und verbrennt Tokens
- Wenn etwas schiefgeht, liest du das ganze Transkript noch mal durch und rätst, was passiert ist
- Er liefert voller Überzeugung kaputte Arbeit ab und nennt sie fertig
- Fünf Minuten kannst du ihn nicht allein lassen, geschweige denn über Nacht
KI-Studiengang Loop Engineering
- Du entwirfst den Loop einmal; danach promptet er sich selbst, bis der Job wirklich erledigt ist
- Stopp-Logik, die bei jedem Durchlauf am richtigen Schritt anhält
- Der Loop kritisiert und behebt seine eigenen Fehler, bevor du sie überhaupt zu Gesicht bekommst
- Er führt seine eigenen Tests aus und weigert sich, bei Rot auszusteigen
- Du kannst dich darauf verlassen, dass er unbeaufsichtigt läuft — über Nacht, bis zu einem verifizierten Ergebnis
What You'll Learn
- Du baust einen einzelnen ReAct-Loop und stattest ihn mit Instrumentierung aus, der eine echte Coding-Aufgabe iterativ löst und pro Schritt seine Überlegungen, Aktionen und Kosten offenlegt.
- Du implementierst Stopp-Logik — Max-Schritte, Budget-Limits, Konfidenz-Schwellen, Fixpunkt-Erkennung —, die einen Loop zum richtigen Zeitpunkt anhält.
- Du implementierst einen Sub-Loop zur Selbstkorrektur (erzeugen → kritisieren → überarbeiten) und beurteilst, wann Reflection hilft und wann sie nur Iterationen verschwendet.
- Du baust Verifikation in den Loop ein, sodass der Agent seine eigene Ausgabe mit Tests, Lintern und Checks prüft, bevor er aussteigt.
- Du unterscheidest die Fehlerbilder eines Loops — Oszillation, Thrashing, vorzeitiger Abbruch, semantische Drift, halluzinierter Erfolg — anhand der Signale einzelner Schritte in einem Trace.
- Du wertest die Signale eines Loops auf Schrittebene aus, um zu erkennen, ob er konvergiert, festhängt oder driftet.
- Du begründest den Trade-off eines Loops zwischen Kosten, Qualität und Iterationen und entscheidest, wo du Schritte kürzt, die Modellstufe wechselst oder früher aussteigst.
- Du entwirfst und lieferst einen produktionsreifen, gehärteten autonomen Loop, der unbeaufsichtigt bis zu einem verifizierten Ergebnis durchläuft.
Lehrplan
Orientierung — Vom Prompt zum Loop
Ordne Loop Engineering in die Reihe Prompt → Kontext → Loop → Harness ein, richte dein Loop-Labor in Claude Code ein und sieh deinem ersten Loop dabei zu, wie er ganz von allein zu einem Ergebnis iteriert.
- Warum Loops die neue Arbeitseinheit sind
- Dein Loop-Labor: Claude Code einrichten
- Erster Erfolg — sieh einem Loop beim Iterieren zu
Anatomie eines funktionierenden Loops
Nimm den Loop Iteration für Iteration auseinander — was das Modell in jeder Runde sieht, was jede Runde kostet, ab wann zusätzliche Iterationen nichts mehr bringen — und bau einen echten, instrumentierten ReAct-Loop für eine Coding-Aufgabe.
- Die vier Takte: Handeln, Beobachten, Entscheiden, Wiederholen
- Bau deinen ersten echten Loop
- Kosten pro Iteration: Was jede Runde wirklich kostet
- Semantische Sättigung: Wann mehr Iterationen nichts mehr bringen
- Einen Trace lesen wie ein Engineer
Termination & Konvergenz
Bring einem Loop bei, wann er stoppen soll. Harte Stopps (Max-Schritte, Budget-Limits), weiche Stopps (Konfidenz-Schwellen, Fixpunkt-Erkennung) und die Grenze zwischen zu frühem Aufgeben und Davonlaufen.
- Das Stopp-Problem
- Harte Stopps: Max-Schritte und Budget-Limits
- Weiche Stopps: Konfidenz und Fixpunkt-Erkennung
- Termination in deinen Loop einbauen
- Kumulative Wiederholung: alles bis einschließlich Termination
Reflection & Selbstkorrektur
Bau Loops, die ihre eigenen Fehler erkennen und beheben. Erzeugen → kritisieren → überarbeiten, internes versus tool-validiertes Feedback und die Über-Reflexions-Falle, in der Kritik nur Iterationen verbrennt.
- Loops, die sich selbst kritisieren
- Internes vs. tool-validiertes Feedback
- Die Über-Reflexions-Falle
- Bau einen Sub-Loop zur Selbstkorrektur
- Modul-Synthese: Reflection, die sich auszahlt
Verifikation im Loop
Hör auf, dem Agenten aufs Wort zu glauben. Verdrahte echte Verifikation — Tests, Linter, Typ-Checks — im Loop, sodass er seine eigene Ausgabe prüft, bevor er aussteigt, mit Rollback, wenn ein Check fehlschlägt.
- Vertrauen ist gut, jeden Schritt prüfen ist besser
- Echte Gates: Tests, Linter, Typen
- Deterministische vs. stochastische Steuerung
- Rollback und Konfidenz-Bewertung
- Bau einen selbstverifizierenden Loop
Fehlerbilder & Debugging
Benenne jede Art, wie ein Loop kaputtgeht — Oszillation, Thrashing, Drift, halluzinierter Erfolg —, statte den Loop mit Signalen auf Schrittebene aus und lerne, jedes Fehlerbild aus seinem Trace zu diagnostizieren und zu beheben.
- Die Taxonomie der Loop-Fehler
- Loop-Instrumentierung: Einblick ins Innere
- Fehler aus Signalen diagnostizieren
- Mach ihn absichtlich kaputt, dann repariere ihn
- Kumulative Wiederholung: Reflection, Verifikation, Fehler
Kosten & Kontrolle
Mach Kosten zu einer erstklassigen Design-Vorgabe. Early-Exit-Strategien, Iterations-Budgets, Modellstufe pro Schritt und Caching — die Rechnung eines Loops drücken, ohne das Ergebnis zu verlieren.
- Der echte Preis eines Loops
- Early-Exit und Iterations-Budgets
- Modellstufe pro Schritt und Caching
- Den Kosten-Qualitäts-Trade-off einstellen
Loops, die laufen, während du schläfst
Überschreite die Autonomie-Schwelle. Checkpoints, Wiederaufnahme und dauerhafter Fortschritt; Termination, Korrektur, Verifikation, Guards und Budgets zu einem Loop zusammensetzen, dem du unbeaufsichtigt vertrauen kannst — und wissen, wann du an ein Harness übergibst.
- Die Autonomie-Schwelle
- Checkpoints, Wiederaufnahme und dauerhafter Fortschritt
- Den vertrauenswürdigen unbeaufsichtigten Loop zusammensetzen
- Wann du an ein Harness übergibst
Capstone — Bau einen produktionsreifen autonomen Loop
Entwirf, bau, instrumentiere und härte einen echten autonomen Loop von Anfang bis Ende — mit Termination, Selbstkorrektur, Verifikation, Fehler-Guards und Kostenkontrolle — und beweise, dass er unbeaufsichtigt bis zu einem verifizierten Ergebnis durchläuft.
- Das Briefing und dein Loop-Design-Dokument
- Bauen, instrumentieren, härten
- Beweise, dass er unbeaufsichtigt läuft
KI-Studiengang Loop Engineering
Belegt, dass du den autonomen Loop eines einzelnen Agenten von Anfang bis Ende bauen kannst — Termination, Selbstkorrektur, Verifikation, Fehlerdiagnose, Kostenkontrolle und unbeaufsichtigter Betrieb — und einen lieferst, der bis zu einem verifizierten Ergebnis durchläuft.
Dein KI-Toolkit
Loop Engineering ist tool-unabhängig, aber du übst an einem echten Coding-Agenten. Alles hier funktioniert in Claude Code; die Muster lassen sich auf Cursor, die rohe API oder dein eigenes Harness übertragen.
Den ganzen Studiengang schaffst du mit einem Claude-Pro-Tarif für rund 20 €/Monat plus ein paar Euro API-Guthaben für die programmatischen Übungen. Kostenpflichtiges Observability-Tooling brauchst du nicht.
About This Degree
Über diesen Studiengang
Jeder Agenten-Kurs zeigt dir, wie du einen Agenten startest. Kaum einer zeigt dir, wie du seinen Loop vertrauenswürdig machst. Genau da klafft die Lücke. Wahrscheinlich hast du schon mal einem Coding-Agenten zugesehen, wie er auf halber Strecke hängenbleibt, bei kaputtem Code den Sieg verkündet oder vierzig Schritte über das Ziel hinaus weiterwerkelt — und du saßt daneben und hast ihn von Hand neu geprompted, weil der Loop nie darauf ausgelegt war, es besser zu machen. Der „Loop" — der Zyklus, in dem der Agent handelt, das Ergebnis beobachtet, entscheidet, was als Nächstes kommt, und das wiederholt, bis der Job erfüllt ist — ist die eigentliche Arbeitseinheit in agentischer KI, und genau die lassen die Kurse aus. Um nichts anderes geht es hier.
Du baust einen Loop, und der wächst mit dir. In Modul 1 startet er als nackter ReAct-Loop, der einen fehlschlagenden Test repariert. In Modul 2 stoppt er am richtigen Schritt statt am Standardwert. In Modul 3 kritisiert und repariert er seine eigenen Fehler; in Modul 4 lässt er deine Test-Suite laufen und weigert sich, bei Rot auszusteigen. Modul 5 härtet ihn gegen die Arten, wie Loops kaputtgehen — Oszillation, Thrashing, Drift, halluzinierter Erfolg —, mithilfe von Signalen, die du aus dem Trace lesen lernst. Modul 6 drückt seine Kosten, ohne das Ergebnis zu verlieren, und Modul 7 bringt ihn über die Autonomie-Schwelle, sodass er unbeaufsichtigt läuft, mit Checkpoints und wiederaufnehmbar. Das Capstone ist genau dieser Loop, fertiggestellt: produktionsreif, dokumentiert und nachweislich in der Lage, zu laufen, während du schläfst.
Was aus dir wird, ist ein Loop Engineer — die Person, die einem Agenten ein Ziel geben und ihm tatsächlich zutrauen kann, es zu erledigen. Nicht weil das Modell schlauer wurde, sondern weil du den Zyklus drumherum gebaut hast: wo er stoppt, wie er sich selbst prüft, was er tut, wenn ein Schritt fehlschlägt, und was er kostet. Das ist die Fähigkeit, die mit besseren Modellen an Wert gewinnt, statt von ihnen ausgelöscht zu werden. Am Ende ist „lass den Agenten das über Nacht erledigen" kein Glücksspiel mehr, sondern etwas, das du selbst entworfen hast.
Prerequisites
Das hier ist ein fortgeschrittener Hands-on-Studiengang. Er setzt voraus, dass du ReAct, Reflection und Tool-Nutzung als Konzepte schon kennst — diese Kurse legen das Fundament, damit wir uns die Grundlagen sparen und direkt am Loop selbst arbeiten.
