Ein projektbasierter Kurs über den Aufbau von Umgebungen, Zustandsverwaltung, Verifizierung und Kontrollmechanismen, die KI-Coding-Agenten zuverlässig machen.
Learn Harness Engineering ist ein Kurs, der sich der Entwicklung von KI-Coding-Agenten widmet. Wir haben die fortschrittlichsten Theorien und Praktiken des Harness Engineering in der Branche eingehend studiert und zusammengefasst. Unsere Kernreferenzen umfassen:
- OpenAI: Harness engineering: leveraging Codex in an agent-first world
- Anthropic: Effective harnesses for long-running agents
- Anthropic: Harness design for long-running application development
- Awesome Harness Engineering
Schneller Einstieg? Der Skill
skills/harness-creator/kann Ihnen helfen, in Minuten ein produktionsreifes Harness (AGENTS.md, Feature-Listen, init.sh, Verifizierungs-Workflows) für Ihr eigenes Projekt zu erstellen.
- Visuelle Vorschau
- Was Harness Engineering wirklich bedeutet
- Schnellstart: Verbessern Sie Ihren Agenten noch heute
- Abschlussprojekt: Eine echte App
- Lernpfad
- Lehrplan
- Skills
- Weitere Kurse
Ein umfassender Kursüberblick und eine Einführung in die Kernphilosophien, die einen klaren Einstiegspfad bieten.
Tiefe Einblicke in reale Problemstellungen und praktische Projekte (wie Projekt 01) für ein immersives Lernerlebnis.
Vorlagen und Referenzkonfigurationen, die entwickelt wurden, um häufige Fallstricke bei der Entwicklung von Multi-Turn-KI-Agenten zu lösen, wie Kontextverlust und vorzeitiger Aufgabenabschluss.
Das Repository enthält nun eine PDF-Build-Pipeline für die Kursinhalte.
- Führen Sie
npm run pdf:buildaus, um englische und chinesische PDFs lokal zu generieren. - Die Ausgabedateien werden in
artifacts/pdfs/geschrieben. - Führen Sie
npm run screenshots:readmeaus, wenn Sie die README-Vorschaubilder aktualisieren möchten. - Der GitHub Actions-Workflow
release-course-pdfs.ymlkann die PDFs erstellen und auf GitHub Releases veröffentlichen.
Es gibt eine harte Wahrheit, die die meisten Menschen auf die harte Tour lernen: Das stärkste Modell der Welt wird bei echten Engineering-Aufgaben dennoch scheitern, wenn Sie keine geeignete Umgebung dafür aufbauen.
Sie haben das wahrscheinlich selbst erlebt. Sie geben Claude oder GPT eine Aufgabe in Ihrem Repo. Es beginnt gut — liest Dateien, schreibt Code, sieht produktiv aus. Dann geht etwas schief. Es überspringt einen Schritt. Es zerstört einen Test. Es sagt „fertig", aber nichts funktioniert tatsächlich. Sie verbringen mehr Zeit mit der Behebung, als wenn Sie es selbst gemacht hätten.
Das ist kein Modellproblem. Es ist ein Harness-Problem.
Die Beweise sind eindeutig. Anthropic führte ein kontrolliertes Experiment durch: gleiches Modell (Opus 4.5), gleicher Prompt („baue einen 2D-Retro-Spieleditor"). Ohne Harness gab es 9 $ in 20 Minuten aus und produzierte etwas, das nicht funktionierte. Mit einem vollständigen Harness (Planer + Generator + Evaluierer) gab es 200 $ in 6 Stunden aus und baute ein Spiel, das man tatsächlich spielen konnte. Das Modell hat sich nicht geändert. Das Harness schon.
OpenAI berichtete dasselbe mit Codex: in einem gut geharnischten Repository wechselt dasselbe Modell von „unzuverlässig" zu „zuverlässig". Keine marginale Verbesserung — ein qualitativer Sprung.
Dieser Kurs bringt Ihnen bei, wie Sie diese Umgebung aufbauen.
DAS HARNESS-MUSTER
==================
Sie --> Aufgabe geben --> Agent liest Harness-Dateien --> Agent führt aus
|
Harness steuert jeden Schritt:
|
+--> Anweisungen: was zu tun ist, in welcher Reihenfolge
+--> Umfang: ein Feature nach dem anderen, keine Übergriffe
+--> Zustand: Fortschrittslog, Feature-Liste, Git-Verlauf
+--> Verifizierung: Tests, Lint, Typprüfung, Smoke-Runs
+--> Lebenszyklus: Initialisierung am Start, sauberer Zustand am Ende
|
v
Agent stoppt nur, wenn
Verifizierung bestanden ist
Harness Engineering handelt davon, eine vollständige Arbeitsumgebung um das Modell herum aufzubauen, damit es zuverlässige Ergebnisse liefert. Es geht nicht darum, bessere Prompts zu schreiben. Es geht darum, das System zu entwerfen, in dem das Modell arbeitet.
Ein Harness hat fünf Subsysteme:
┌─────────────────────────────────────────────────────────────────┐
│ DAS HARNESS │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
│ │ Anweisungen │ │ Zustand │ │ Verifizierung │ │
│ │ │ │ │ │ │ │
│ │ AGENTS.md │ │ progress.md │ │ Tests + Lint │ │
│ │ CLAUDE.md │ │ feature_list │ │ Typprüfung │ │
│ │ feature_list │ │ git log │ │ Smoke-Runs │ │
│ │ docs/ │ │ Session-Übg. │ │ E2E-Pipeline │ │
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
│ │
│ ┌──────────────┐ ┌──────────────────────────────────────┐ │
│ │ Umfang │ │ Session-Lebenszyklus │ │
│ │ │ │ │ │
│ │ ein Feature │ │ init.sh am Start │ │
│ │ nach dem and.│ │ Clean-State-Checkliste am Ende │ │
│ │ Definition │ │ Übergabenotiz für nächste Session │ │
│ │ von Fertig │ │ Commit nur wenn sicher fortsetzbar │ │
│ └──────────────┘ └──────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Das MODELL entscheidet, welcher Code geschrieben wird.
Das HARNESS steuert, wann, wo und wie es geschrieben wird.
Das Harness macht das Modell nicht schlauer.
Es macht die Ausgabe des Modells zuverlässig.
Jedes Subsystem hat eine Aufgabe:
- Instructions — Dem Agenten sagen, was zu tun ist, in welcher Reihenfolge und was er lesen soll, bevor er beginnt. Nicht eine riesige Datei; eine progressive Enthüllungsstruktur, die der Agent nach Bedarf navigiert.
- State — Verfolgen, was erledigt wurde, was in Bearbeitung ist und was als Nächstes ansteht. Auf der Festplatte gespeichert, damit die nächste Session genau dort ansetzt, wo die letzte aufgehört hat.
- Verification — Nur eine bestehende Testsuite gilt als Nachweis. Der Agent kann keinen Erfolg melden ohne ausführbaren Beweis.
- Scope — Den Agenten auf ein Feature gleichzeitig beschränken. Keine Übergriffe. Kein halbfertiges Abschließen von drei Dingen. Kein Umschreiben der Feature-Liste, um unfertige Arbeit zu verbergen.
- Session Lifecycle — Initialisierung am Anfang. Aufräumen am Ende. Einen sauberen Neustartpfad für die nächste Sitzung hinterlassen.
Die Frage ist nicht „Können Modelle Code schreiben?" Sie können. Die Frage ist: Können sie zuverlässig echte Engineering-Aufgaben in echten Repositories über mehrere Sessions hinweg absolvieren, ohne ständige menschliche Überwachung?
Im Moment lautet die Antwort: nicht ohne ein Harness.
OHNE HARNESS MIT HARNESS
=========== ===========
Session 1: Agent schreibt Code Session 1: Agent liest Anweisungen
Agent zerstört Tests Agent führt init.sh aus
Agent sagt "fertig" Agent arbeitet an einem Feature
Sie reparieren manuell Agent verifiziert vor Fertig-Meldung
Agent aktualisiert Fortschrittslog
Session 2: Agent startet neu Agent committet sauberen Zustand
Agent hat keine Erinnerung
an vorherige Session Session 2: Agent liest Fortschrittslog
Agent macht Arbeit neu Agent setzt genau dort fort
oder macht etwas ganz anderes Agent bearbeitet das unfertige Feature
Sie reparieren wieder Sie überprüfen, statt zu retten
Ergebnis: Sie verbringen mehr Zeit Ergebnis: Agent erledigt die Arbeit,
mit Aufräumen, als wenn Sie verifizieren das Ergebnis
Sie es selbst gemacht hätten
Die Fragen, die dieser Kurs wirklich interessieren:
- Welche Harness-Designs verbessern die Aufgabenabschlussraten?
- Welche Designs reduzieren Nacharbeit und falsche Abschlüsse?
- Welche Mechanismen halten langlaufende Aufgaben stetig voran?
- Welche Strukturen halten das System nach mehreren Agenten-Läufen wartbar?
Die vollständigen Kursmaterialien finden Sie auf der Dokumentations-Website.
Das Curriculum ist in drei Teile gegliedert:
- Vorlesungen: 12 konzeptionelle Einheiten, die die Theorie hinter dem Harness Engineering erklären.
- Projekte: 6 praktische Projekte, bei denen Sie einen agentenbasierten Arbeitsbereich von Grund auf neu aufbauen.
- Vorlagen-Bibliothek: Kopierfertige Vorlagen (
AGENTS.md,feature_list.json,init.shusw.), die Sie noch heute in Ihren eigenen Repositories verwenden können.
Sie müssen nicht alle 12 Vorlesungen lesen, bevor Sie einen Nutzen ziehen. Wenn Sie bereits einen Coding-Agenten in einem echten Projekt einsetzen, können Sie ihn jetzt sofort verbessern.
Die Idee ist einfach: Anstatt nur Prompts zu schreiben, geben Sie Ihrem Agenten einen Satz strukturierter Dateien, die definieren, was zu tun ist, was bereits erledigt ist und wie die Arbeit verifiziert wird. Diese Dateien befinden sich in Ihrem Repo, sodass jede Session vom gleichen Zustand ausgeht.
IHR PROJEKT-ROOT
├── AGENTS.md <-- das Betriebshandbuch des Agenten
├── CLAUDE.md <-- (Alternative, wenn Sie Claude Code verwenden)
├── init.sh <-- führt install + verify + start aus
├── feature_list.json <-- welche Features existieren, welche erledigt sind
├── claude-progress.md <-- was in jeder Session passiert ist
└── src/ <-- Ihr tatsächlicher Code
Laden Sie sich die Starter-Vorlagen aus der Vorlagen-Bibliothek herunter und fügen Sie sie in Ihr Projekt ein. Das war's. Vier Dateien, und Ihre Agenten-Sessions werden bereits deutlich stabiler sein als mit Prompts allein.
Alle sechs Kursprojekte drehen sich um dasselbe Produkt: eine Electron-basierte Desktop-App für persönliches Wissensmanagement.
┌─────────────────────────────────────────────────────┐
│ Wissensdatenbank-Desktop-App │
│ │
│ ┌──────────────┐ ┌──────────────────────────────┐│
│ │ Dokumenten- │ │ F&A-Panel ││
│ │ liste │ │ ││
│ │ doc-001.md │ │ F: Was ist Harness Eng.? ││
│ │ doc-002.md │ │ A: Die Umgebung, die um ││
│ │ doc-003.md │ │ ein Agentenmodell... ││
│ │ ... │ │ [Zitat: doc-002.md] ││
│ └──────────────┘ └──────────────────────────────┘│
│ │
│ ┌─────────────────────────────────────────────────┐│
│ │ Statusleiste: 42 Doks | 38 indiziert | letzte Sync 3m ││
│ └─────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────┘
Kernfunktionen:
├── Lokale Dokumente importieren
├── Eine Dokumentenbibliothek verwalten
├── Dokumente verarbeiten und indizieren
├── KI-gestützte F&A über importierte Inhalte ausführen
└── Fundierte Antworten mit Quellnachweisen liefern
Dieses Projekt wurde gewählt, weil es hohen praktischen Nutzen, ausreichende reale Produktkomplexität und ein gutes Szenario für die Beobachtung von Harness-Verbesserungen (Vorher/Nachher) verbindet.
Jedes Kursprojekt (Starter/Lösung) ist eine vollständige Kopie dieser Electron-App im jeweiligen Entwicklungsstadium. Der Starter von P(N+1) wird aus der Lösung von P(N) abgeleitet — die App entwickelt sich weiter, während Ihre Harness-Fähigkeiten wachsen.
Der Kurs ist für die chronologische Abarbeitung konzipiert. Jede Phase baut auf der vorherigen auf.
Phase 1: DAS PROBLEM ERKENNEN Phase 2: DAS REPO STRUKTURIEREN
============================== ===============================
L01 Starke Modelle ≠ zuverlässige L03 Repository als einzige
Ausführung Wahrheitsquelle
L02 Was ein Harness wirklich bedeutet
L04 Anweisungen auf mehrere
| Dateien aufteilen, nicht eine riesige
v
P01 Nur-Prompt vs. |
regelbasierter Vergleich v
P02 Agentenlesbarer Arbeitsbereich
Phase 3: SESSIONS VERBINDEN Phase 4: FEEDBACK & UMFANG
=========================== =========================
L05 Kontext über Sessions hinweg L07 Klare Aufgabengrenzen ziehen
lebendig halten
L08 Feature-Listen als Harness-
L06 Vor jeder Agenten-Session Primitive
initialisieren
|
| v
v P04 Laufzeit-Feedback zur
P03 Multi-Session-Kontinuität Korrektur des Agentenverhaltens
Phase 5: VERIFIZIERUNG Phase 6: ALLES ZUSAMMENFÜHREN
======================= ==============================
L09 Agenten davon abhalten, L11 Laufzeit des Agenten
zu früh Erfolg zu melden beobachtbar machen
L10 Vollständiger Pipeline-Lauf = L12 Saubere Übergabe am Ende
echte Verifizierung jeder Session
| |
v v
P05 Agent verifiziert seine P06 Ein vollständiges Harness
eigene Arbeit aufbauen (Abschlussprojekt)
Jede Phase dauert etwa eine Woche, wenn Sie nebenbei lernen. Wenn Sie schneller vorgehen möchten, können die Phasen 1–3 an einem langen Wochenende absolviert werden.
Lesen Sie den vollständigen Text jeder Vorlesung auf der Dokumentations-Website.
| Session | Frage | Kernidee |
|---|---|---|
| L01 | Warum scheitern starke Modelle dennoch bei echten Aufgaben? | Die Lücke zwischen Benchmarks und echtem Engineering |
| L02 | Was bedeutet „Harness" eigentlich? | Fünf Subsysteme: Instructions, State, Verification, Scope, Lifecycle |
| L03 | Warum muss das Repo die einzige Quelle der Wahrheit sein? | Wenn der Agent es nicht sehen kann, existiert es nicht |
| L04 | Warum scheitert eine einzige riesige Instruktionsdatei? | Progressive Enthüllung: eine Karte geben, keine Enzyklopädie |
| L05 | Warum verlieren langlaufende Aufgaben ihre Kontinuität? | Fortschritt auf der Festplatte speichern; dort fortfahren, wo man aufgehört hat |
| L06 | Warum braucht die Initialisierung eine eigene Phase? | Die Umgebung auf Funktionsfähigkeit prüfen, bevor der Agent mit der Arbeit beginnt |
| L07 | Warum greifen Agenten über und schließen unvollständig ab? | Ein Feature gleichzeitig; explizite Definition von „Fertig" |
| L08 | Warum sind Feature-Listen Harness-Primitiven? | Maschinenlesbare Scope-Grenzen, die der Agent nicht ignorieren kann |
| L09 | Warum melden Agenten zu früh den Erfolg? | Verifizierungslücken: Vertrauen ≠ Korrektheit |
| L10 | Warum ändert End-to-End-Testing die Ergebnisse? | Nur ein vollständiger Pipeline-Lauf gilt als echte Verifizierung |
| L11 | Warum gehört Observability in das Harness? | Wenn Sie nicht sehen können, was der Agent getan hat, können Sie nicht reparieren, was er zerstört hat |
| L12 | Warum muss jede Session einen sauberen Zustand hinterlassen? | Der Erfolg der nächsten Session hängt vom Aufräumen dieser Session ab |
| Projekt | Was Sie tun | Harness-Mechanismus |
|---|---|---|
| P01 | Dieselbe Aufgabe zweimal ausführen: nur Prompt vs. regelnbasiert | Minimales Harness: AGENTS.md + init.sh + feature_list.json |
| P02 | Das Repo umstrukturieren, damit der Agent es lesen kann | Agentenlesbarer Arbeitsbereich + persistente Zustandsdateien |
| P03 | Den Agenten dort fortfahren lassen, wo er aufgehört hat | Fortschrittsprotokoll + Session-Übergabe + Multi-Session-Kontinuität |
| P04 | Den Agenten davon abhalten, zu viel oder zu wenig zu tun | Laufzeit-Feedback + Scope-Kontrolle + inkrementelle Indizierung |
| P05 | Den Agenten seine eigene Arbeit verifizieren lassen | Selbstverifizierung + fundierte Q&A + evidenzbasierter Abschluss |
| P06 | Ein vollständiges Harness von Grund auf neu aufbauen (Abschlussprojekt) | Vollständiges Harness: alle Mechanismen + Observability + Ablationsstudie |
PROJEKTENTWICKLUNG
==================
P01 Nur-Prompt vs. regelbasiert Sie erkennen das Problem
|
v
P02 Agentenlesbarer Arbeitsbereich Sie restrukturieren das Repo
|
v
P03 Multi-Session-Kontinuität Sie verbinden Sessions
|
v
P04 Laufzeit-Feedback & Umfang Sie fügen Feedback-Schleifen hinzu
|
v
P05 Selbstverifizierung Sie lassen den Agenten sich selbst prüfen
|
v
P06 Vollständiges Harness (Abschluss) Sie bauen das Gesamtsystem
Die Lösung jedes Projekts wird zum Starter des nächsten Projekts.
Die App entwickelt sich weiter. Ihre Harness-Fähigkeiten wachsen mit.
- English — templates, checklists, and method references
- 简体中文 — 中文模板、清单和方法参考
- 繁體中文 — 繁體中文範本、清單和方法參考
- 日本語 — テンプレート、チェックリスト、方法リファレンス
- 한국어 — 템플릿, 체크리스트, 방법 참고 자료
- Español — plantillas, listas de verificación y referencias
- Français — modèles, listes de contrôle et références
- Русский — шаблоны, чек-листы и справочники
- Deutsch — Vorlagen, Checklisten und Referenzen
- العربية — قوالب، قوائم تحقق ومراجع
- Tiếng Việt — mẫu, danh sách kiểm tra và tài liệu tham khảo
- Oʻzbekcha — andozalar, tekshiruv roʻyxatlari va maʼlumotnomalar
- Türkçe — şablonlar, kontrol listeleri ve referanslar
- Português (BR) — modelos, listas de verificação e referências de métodos
Eine der Kernideen dieses Kurses: Die Session eines Agenten sollte einem strukturierten Lebenszyklus folgen, keinem Freifür-alle. So sieht das aus:
AGENTEN-SESSION-LEBENSZYKLUS
============================
┌──────────────────────────────────────────────────────────────────┐
│ START │
│ │
│ 1. Agent liest AGENTS.md / CLAUDE.md │
│ 2. Agent führt init.sh aus (Installieren, Verifizieren, Check) │
│ 3. Agent liest claude-progress.md (was letztes Mal passierte) │
│ 4. Agent liest feature_list.json (was erledigt, was als Nächstes)│
│ 5. Agent prüft git log (letzte Änderungen) │
│ │
│ AUSWAHL │
│ │
│ 6. Agent wählt genau EIN unfertiges Feature aus │
│ 7. Agent arbeitet nur an diesem Feature │
│ │
│ AUSFÜHRUNG │
│ │
│ 8. Agent implementiert das Feature │
│ 9. Agent führt Verifizierung aus (Tests, Lint, Typprüfung) │
│ 10. Wenn Verifizierung fehlschlägt: korrigieren und neu ausf. │
│ 11. Wenn Verifizierung bestanden: Beweise dokumentieren │
│ │
│ ABSCHLUSS │
│ │
│ 12. Agent aktualisiert claude-progress.md │
│ 13. Agent aktualisiert feature_list.json │
│ 14. Agent dokumentiert, was noch kaputt oder unverifiziert ist │
│ 15. Agent committet (nur wenn sicher fortsetzbar) │
│ 16. Agent hinterlässt sauberen Neustartpfad für nächste Session│
│ │
└──────────────────────────────────────────────────────────────────┘
Das Harness steuert jeden Übergang in diesem Lebenszyklus.
Das Modell entscheidet, welcher Code bei jedem Schritt geschrieben wird.
Ohne Harness wird Schritt 9 zu „Agent sagt, es sieht gut aus."
Mit Harness ist Schritt 9: „Tests bestanden, Lint sauber, Typen geprüft."
Dieser Kurs richtet sich an:
- Entwickler, die bereits Coding-Agenten verwenden und mehr Stabilität und Qualität möchten
- Forscher oder Entwickler, die ein systematisches Verständnis des Harness-Designs erwerben möchten
- Tech-Leads, die verstehen möchten, wie Umgebungsdesign die Agentenleistung beeinflusst
Dieser Kurs richtet sich nicht an:
- Personen, die eine Einführung in KI ohne Programmierung suchen
- Personen, die sich nur für Prompts interessieren und keine echten Implementierungen planen
- Lernende, die nicht bereit sind, Agenten in echten Repositories arbeiten zu lassen
Dies ist ein Kurs, in dem Sie tatsächlich Coding-Agenten ausführen.
Sie benötigen mindestens eines dieser Werkzeuge:
- Claude Code
- Codex
- Einen anderen IDE- oder CLI-Coding-Agenten, der Dateibearbeitung, Befehlsausführung und mehrstufige Aufgaben unterstützt
Der Kurs setzt voraus, dass Sie:
- Ein lokales Repository öffnen können
- Dem Agenten erlauben können, Dateien zu bearbeiten
- Dem Agenten erlauben können, Befehle auszuführen
- Ausgaben überprüfen und Aufgaben neu starten können
Wenn Sie über kein solches Werkzeug verfügen, können Sie die Kursinhalte dennoch lesen, aber Sie werden die Projekte nicht wie vorgesehen abschließen können.
Dieses Repository verwendet VitePress als Dokumentationsbetrachter.
npm install
npm run docs:dev # Dev-Server mit Hot Reload
npm run docs:build # Produktions-Build
npm run docs:preview # Vorschau der erstellten SeiteÖffnen Sie dann die lokale URL, die VitePress ausgibt, in Ihrem Browser.
Erforderlich:
- Vertrautheit mit dem Terminal, Git und lokalen Entwicklungsumgebungen
- Fähigkeit, Code in mindestens einem gängigen Anwendungsstack zu lesen und zu schreiben
- Grundlegende Software-Debugging-Erfahrung (Lesen von Logs, Tests und Laufzeitverhalten)
- Ausreichend Zeit für implementationsfokussierte Kursarbeit
Hilfreich, aber nicht erforderlich:
- Erfahrung mit Electron, Desktop-Apps oder Local-First-Tools
- Hintergrund in Testing, Logging oder Softwarearchitektur
- Frühere Erfahrung mit Codex, Claude Code oder ähnlichen Coding-Agenten
Primär:
- OpenAI: Harness engineering: leveraging Codex in an agent-first world
- Anthropic: Effective harnesses for long-running agents
- Anthropic: Harness design for long-running application development
- OpenAI: Unrolling the Codex agent loop
- Anthropic: Demystifying evals for AI agents
- LangChain: Improving Deep Agents with harness engineering
- Thoughtworks / Martin Fowler: Harness engineering for coding agent users
- Cursor: Continually improving our agent harness
Die vollständige geschichtete Referenzliste finden Sie in docs/en/resources/reference/.
learn-harness-engineering/
├── docs/ # VitePress-Dokumentationsseite
│ ├── lectures/ # 12 Vorlesungen (index.md + code/ Beispiele)
│ │ ├── lecture-01-*/
│ │ ├── lecture-02-*/
│ │ └── ... (insgesamt 12)
│ ├── projects/ # 6 Projektbeschreibungen
│ │ ├── project-01-*/
│ │ └── ... (insgesamt 6)
│ └── resources/ # Mehrsprachige Vorlagen & Referenzen
│ ├── en/ # Englische Vorlagen, Checklisten, Leitfäden
│ ├── zh/ # Chinesische Vorlagen, Checklisten, Leitfäden
│ ├── ru/ # Russische Vorlagen, Checklisten, Leitfäden
│ └── vi/ # Vietnamesische Vorlagen, Checklisten, Leitfäden
├── projects/
│ ├── shared/ # Gemeinsame Electron + TypeScript + React-Basis
│ └── project-NN/ # Projektbezogene starter/ und solution/ Verzeichnisse
├── skills/ # Wiederverwendbare KI-Agenten-Skills
│ └── harness-creator/ # Harness Engineering Skill
├── package.json # VitePress + Dev-Werkzeuge
└── CLAUDE.md # Claude Code-Anweisungen für dieses Repo
- Jede Vorlesung konzentriert sich auf eine Frage
- Der Kurs umfasst 6 Projekte
- Jedes Projekt erfordert, dass der Agent echte Arbeit leistet
- Jedes Projekt vergleicht schwache vs. starke Harness-Ergebnisse
- Was zählt, ist der gemessene Unterschied, nicht wie viele Dokumente geschrieben wurden
Dieses Repository enthält auch wiederverwendbare KI-Agenten-Skills, die Sie direkt in Ihre IDE oder Ihren Agenten-Arbeitsbereich installieren können.
- harness-creator: Ein Skill, der Ihnen hilft, in Minuten ein produktionsreifes Harness für Ihr eigenes Projekt zu erstellen.
Unser Team hat auch weitere Kurse erstellt! Schauen Sie sich diese an:
Hands-on Modern RL: Ein Open-Source-Praxiscurriculum, das die Lücke von grundlegenden RL-Konzepten zu LLM-Alignment, RLVR und fortschrittlichen agentischen Systemen überbrückt.
Dieser Kurs wurde inspiriert von und bezieht Ideen aus learn-claude-code — einem fortschreitenden Leitfaden zum Aufbau eines Agenten von Grund auf, von einem einzelnen Loop bis zur isolierten autonomen Ausführung.