KI-Zertifikatsprogramm 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.
Warum das hier statt eines klassischen Studiums?
- 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
- 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.
Orientierung — Vom Prompt zum Loop
Portfolio-Projekt: Ein eingerichtetes Loop-Labor und dein erster beobachteter, instrumentierter Loop-Durchlauf.
Modul startenAnatomie 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.
Anatomie eines funktionierenden Loops
Portfolio-Projekt: Ein funktionierender, instrumentierter ReAct-Loop, der einen echten fehlschlagenden Test repariert und seine Kosten pro Schritt zeigt.
Modul startenTermination & 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.
Termination & Konvergenz
Portfolio-Projekt: Dein Loop mit eingebauter Termination, die am richtigen Schritt anhält statt am Standardwert.
Modul startenReflection & 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.
Reflection & Selbstkorrektur
Portfolio-Projekt: Dein Loop mit einem Sub-Loop zur Selbstkorrektur, der eigene Fehler mitten im Durchlauf erkennt und behebt.
Modul startenVerifikation 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.
Verifikation im Loop
Portfolio-Projekt: Dein Loop mit einem Verifikations-Gate, das sich weigert auszusteigen, bis seine eigenen Checks auf Grün stehen.
Modul startenFehlerbilder & 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.
Fehlerbilder & Debugging
Portfolio-Projekt: Ein Diagnose-Bericht plus ein Loop, der gegen die häufigsten Fehlerbilder gehärtet ist.
Modul startenKosten & 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.
Kosten & Kontrolle
Portfolio-Projekt: Dein Loop neu eingestellt, sodass er dasselbe Ergebnis zu einem Bruchteil der Token-Kosten erreicht.
Modul startenLoops, 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.
Loops, die laufen, während du schläfst
Portfolio-Projekt: Dein Loop, der über Unterbrechungen hinweg unbeaufsichtigt läuft, mit Checkpoints und wiederaufnehmbarem Fortschritt.
Modul startenCapstone — 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.
Capstone — Bau einen produktionsreifen autonomen Loop
Portfolio-Projekt: Ein produktionsreifer autonomer Loop, ein Loop-Design-Dokument und ein Trace, der einen unbeaufsichtigten, verifizierten Durchlauf belegt.
Modul startenDein 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.
Dein zentrales Loop-Labor — agentische Loops gegen ein echtes Repo laufen lassen, instrumentieren und härten (Module 0–8)
Claude Pro rund 20 €/Monat, oder API-GuthabenLoops programmatisch steuern — Temperatur, Modellstufe und Budget pro Schritt kontrollieren
Abrechnung pro Token (ein paar Euro decken das ganze Programm)Die Codebasis, auf die deine Loops einwirken und gegen die sie mit Tests und Lintern verifizieren
KostenlosIns Innere eines Loops schauen — Überlegungen, Aktionen, Tokens und Drift pro Schritt
Kostenlos (in Claude Code eingebaut) oder Langfuse Free-TarifEin schlankes Loop-Harness schreiben, wenn du volle Kontrolle über den Zyklus willst
KostenlosDas ganze Programm 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.
Über dieses Programm
Über dieses Programm
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.
Voraussetzungen
Das hier ist ein fortgeschrittenes Hands-on-Zertifikatsprogramm. Es 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.
Vermittelt ReAct, Reflection und die Anatomie eines Agenten — die Muster, die dieses Programm in die Tiefe baut, statt sie neu zu erklären.
Behandelt, was Agenten sind, Tool-Nutzung und Entscheidungspunkte — das Fundament, das wir ab der ersten Lektion voraussetzen.
Führt das Evaluator-Optimizer-Muster und Quality Gates ein — die Keimzelle von Selbstkorrektur und Verifikation mitten im Loop.
Häufige Fragen
Für wen ist dieses Programm?
Für Entwicklerinnen und technische Builder, die schon den einen oder anderen Agenten gebaut haben, deren Loops aber unzuverlässig sind — sie stoppen zu früh, laufen davon, wiederholen Fehler oder sind unbeaufsichtigt nicht vertrauenswürdig. Wenn du Code lesen und einen Coding-Agenten bedienen kannst, bist du bereit.
Muss ich Code schreiben?
Ja. Das ist ein Programm für Builder. Du lässt in jedem Modul einen Coding-Agenten (Claude Code) gegen ein echtes Repo laufen und schreibst etwas Python, wenn du volle Kontrolle über den Loop willst. Ab Modul 1 geht es ans Eingemachte.
Ersetzt KI Entwickler — oder Loop Engineers?
Hier wirkt der umgekehrte Druck. Je stärker die Modelle werden, desto mehr verschiebt sich der Engpass vom Code-Schreiben hin zum Entwurf des Loops, der einen Agenten autonom und korrekt arbeiten lässt. Loop Engineering ist die Fähigkeit, die mit besseren Agenten an Wert gewinnt — nicht die, die sie auslöschen.
Welche Voraussetzungen brauche ich?
Drei Kurse: AI Agents Deep Dive, Building AI Agents & Workflows und Prompt Chaining & Workflows. Zusammen decken sie ReAct, Reflection, Tool-Nutzung und Quality Gates als Konzepte ab — dieses Programm setzt all das voraus und baut es technisch aus.
Was bekomme ich am Ende?
Ein Capstone-Projekt mit Portfolio-Niveau: einen produktionsreifen autonomen Loop für eine echte Coding-Aufgabe, ein Loop-Design-Dokument und einen Trace, der belegt, dass er unbeaufsichtigt bis zu einem verifizierten Ergebnis lief — dazu das Abschlusszertifikat KI Loop Engineering.
Wie lange dauert das Programm?
Bei stetigem Tempo etwa vier Wochen — neun Module, 39 Lektionen, rund 22 Stunden inklusive der praktischen Übungen. Du lernst im eigenen Tempo, also kannst du schneller oder langsamer machen.
Erkennen Arbeitgeber dieses Programm an?
Das Zertifikat signalisiert die Fähigkeit; das Capstone beweist sie. Ein autonomer Loop, der sich selbst korrigiert, sich selbst verifiziert und unbeaufsichtigt läuft — mit einem Design-Dokument, das deine Entscheidungen erklärt —, ist ein konkretes Artefakt, das du im Vorstellungsgespräch oder im PR-Review zeigen kannst.
Brauche ich ein bestimmtes Tool?
Wir unterrichten in Claude Code, weil es der sauberste Ort ist, um echte agentische Loops laufen zu lassen und zu inspizieren — aber Loop Engineering ist tool-unabhängig. Jedes Muster lässt sich auf Cursor, die rohe API oder ein selbst geschriebenes Harness übertragen.
Welche KI-Tools nutze ich?
Claude Code als dein Loop-Labor, eine Modell-API (Claude, GPT oder Gemini) für die programmatischen Übungen, ein Scratch-Git-Repo mit Test-Suite und eine Trace-Ansicht, um ins Innere deiner Loops zu schauen.
Wie unterscheidet sich das von den Voraussetzungskursen?
Die Kurse zeigen dir, dass ReAct, Reflection und Quality Gates existieren und wie man sie einmal anwendet. Dieses Programm baut sie technisch aus: was zu tun ist, wenn ein Loop divergiert, wie du ihn zum Konvergieren bringst, wie du mitten im Loop verifizierst, wie du Fehler aus einem Trace diagnostizierst und wie du ihn unbeaufsichtigt laufen lässt. Weniger als 10 % Überschneidung — so gewollt.
Wie unterscheidet sich das von den Programmen AI Agent Harness und AI Agent Builder?
Bei Loop Engineering geht es um das, was im Iterieren-bis-fertig-Zyklus eines einzelnen Agenten passiert — wie er denkt, prüft, korrigiert und stoppt. Beim Agent Harness geht es um das System rund um den Loop (Frameworks, Multi-Agent-Topologie, Evaluations-Infrastruktur). Beim Agent Builder geht es darum, ganze Riegen von Agenten sicher in einer Organisation zu betreiben. Sie ergänzen sich; dieser hier ist der tiefste Tauchgang in den Loop selbst.
Ist Loop Engineering nur für Coding-Agenten?
Der Loop ist die Einheit, und bei Coding-Agenten ist er am schärfsten, weil der Agent Tests laufen lassen kann, um seine eigene Arbeit zu verifizieren. Aber die Prinzipien — Termination, Selbstkorrektur, Verifikation, Fehlerdiagnose, Kostenkontrolle — gelten auch für Recherche-Agenten, Datenverarbeitungs-Agenten und jeden autonomen Loop.
