Zum Inhalt springen
agenticbuilders
Gratis-Handout

KI-App bauen lernen: die kuratierte Startseite.

Hier findest du den roten Faden, wenn du mit KI-Agenten bauen willst: erst verstehen, dann kleine Schritte planen, Ergebnisse prüfen und die nächste Runde sauber führen. Der Engpass ist nicht mehr nur Code, sondern Kontext, klare Aufträge und echte Verifikation.

Stand: 2026-06-12 · frei weitergebbar

Die vier Leitprinzipien

Diese vier Prinzipien überleben jeden Tool-Wechsel. Wer sie verinnerlicht, kann jedes Werkzeug lernen.

  1. Lern den Loop, nicht die Buttons.

    Features verfallen. Was bleibt, ist der Loop: Kontext sammeln, planen, handeln, verifizieren, wiederholen. Investiere ins Fundament, nicht in Feature-Touren.

  2. Prüfen ist der Schlüssel-Skill.

    Gib dem Agenten einen Check, den er selbst laufen lassen kann, und verlange Evidenz statt blindem Vertrauen. Kleine, überprüfbare Diffs schlagen große.

  3. Vibe Engineering, nicht blindes Vibe Coding.

    Ungereviewter Code ist für Prototypen ok, in Produktion riskant. Die Verantwortung bleibt immer beim Menschen. Das ist der Glaubwürdigkeits-Anker.

  4. Delegation bewusst erhöhen.

    KI berührt heute viel Arbeit, aber nur ein kleiner Teil ist voll und sicher delegierbar. Jede Technik muss diese Frage beantworten: bringt sie mich zu höherer, sicherer Delegation?

Der Lernpfad

Vier Stufen, jede mit Lernzielen und den besten Ressourcen, um dorthin zu kommen. Claude Code bleibt der rote Faden, Codex ergänzt die Ökosystem-Spur über Skills, Plugins und App-Integrationen. Die Konzepte gelten auch für andere Tools.

  1. Stufe 0: Verstehen, warum sich gerade alles ändert

    Bevor du ein Tool anfasst: das Mindset. Drei Quellen für den konzeptionellen Rahmen.

  2. Stufe 1: Foundations

    Ein Coding-Agent läuft auf deiner Maschine. Du verstehst den Loop, prompst spezifisch, liest Diffs, steuerst eine Session und committest als Sicherheitsnetz.

  3. Stufe 2: Der produktive Arbeits-Loop

    Du arbeitest im Muster Explore -> Plan -> Code -> Commit, beherrschst Spec-first und die Verification-Leiter, und hältst Context-Hygiene.

  4. Stufe 3: Skalierung, Automation & Cross-Tool-Literacy

    Context Engineering als Disziplin, Skills und Plugins als wiederverwendbare Workflows, Hooks, MCP und CI-Automation. Du fährst den Loop auch in Cursor, Codex oder Aider.

Der passende Kurs pro Stufe

Häufige Fehler-Muster

Die häufigsten Stolpersteine zu erkennen und zu beheben ist ein eigener Skill.

Alles-in-einer-Session

Eine Session sammelt 5 Tasks an, der Kontext überfüllt, die Qualität sinkt.

Gegenmittel: /clear zwischen Tasks; eine Session = eine Aufgabe.

Korrektur-Schleife

4., 5., 6. Korrektur-Prompt, und es wird nicht besser.

Gegenmittel: Nach ~2 Fehlversuchen neu starten statt weiterkämpfen.

Überladene CLAUDE.md

Die Memory-Datei ist 300 Zeilen, der Agent ignoriert das Meiste.

Gegenmittel: Kurz und hoch-signalhaft halten. Nur was wirklich gilt.

Trust-then-verify-Lücke

Der Output sieht plausibel aus und wird ungeprüft übernommen.

Gegenmittel: Evidenz verlangen, Check laufen lassen, Reviewer-Subagent ansetzen.

Endloses Erkunden

Der Agent liest endlos, handelt aber nie.

Gegenmittel: Aufgabe scopen, Plan erzwingen, auf Files und Patterns zeigen.

Proof of Method

Zahlen aus dem Maschinenraum

Was du hier liest, kommt nicht aus einem Theorie-Kurs, sondern aus echtem Betrieb. Diese Kennzahlen stammen aus dem orchestrierten Workflow hinter dieser Seite und verweisen auf das öffentliche Werkzeug dahinter.

Stand: 2026-06

Orchestrierte Sessions
800+
Dokumentierte Arbeits-Sessions über 24 reale Projekte.
Dokumentierte Learnings
1.300+
Über 300 davon verifiziert.
Agent-Läufe
15.000+
Einzelne Agent-Läufe im orchestrierten Workflow, dokumentiert über alle Sessions.
Parallele Agents
bis zu 34
In einer Session koordiniert, im Median 10 pro Deep-Session.

* Stand Juni 2026, erhoben aus dem orchestrierten Workflow hinter dieser Seite (Open-Source-Plugin session-orchestrator, MIT). Eine orchestrierte Session ist ein abgeschlossener Arbeitsblock, in dem ein Koordinator die Aufgabe in Wellen an mehrere KI-Agenten verteilt. Jede Session wird dokumentiert; Learnings sind die festgehaltenen Erkenntnisse daraus, projektübergreifend gezählt. Alle Werte sind konservative Untergrenzen, über 300 der Learnings sind verifiziert.

Erhoben mit dem Open-Source-Plugin session-orchestrator (MIT), dem Werkzeug hinter diesen Sessions.

Du willst verstehen, wie das System dahinter funktioniert? Kurs: Multi-Agent-Orchestrierung in der Praxis (bald verfügbar, €49)

Diese Liste ist die Landkarte.

Das Handout ist der erste geführte Schritt darauf: kein Video-Kurs, keine Registrierung über die E-Mail hinaus. Ein PDF, das du in einer Stunde durcharbeitest, mit einem echten Methode-Loop, den du sofort auf dein eigenes Projekt anwendest.

Ehrlich gesagt: Die Tiefe mit den zehn Use-Cases und den Verlässlichkeits-Themen steckt im € 29-Guide. Aber die Eingangstür ist kostenlos, und sie reicht für den ersten sauberen Build.

Gratis-Handout holen

Linkreferenz (kuratiert)

Bewusst kuratiert statt Link-Dump. Die volle Tiefe steckt im Guide.

37 von 37 Ressourcen

Kanonische PrimärquellenBest Practices for Claude Code (öffnet in neuem Tab)

Die kanonischen Patterns: Kontext-Management, Plan Mode, parallele Sessions.

Quelle auf EnglischKanonische PrimärquellenEffective context engineering for AI agents (öffnet in neuem Tab)

Das Kontextfenster effizient befüllen und verwalten.

Quelle auf EnglischKanonische PrimärquellenBuilding effective agents (öffnet in neuem Tab)

Grundlagen-Artikel zu kompositorischen Agenten-Patterns.

Quelle auf EnglischKanonische PrimärquellenAnthropic Academy: alle Kurse (öffnet in neuem Tab)

~17 Gratis-Kurse plus Zertifikate, nur E-Mail nötig.

Quelle auf EnglischgratisKanonische PrimärquellenClaude Code Quickstart (öffnet in neuem Tab)

Von der Installation bis zum ersten Commit.

Quelle auf EnglischKanonische PrimärquellenMemory / CLAUDE.md (öffnet in neuem Tab)

Projekt-Instruktionen und Auto-Memory.

Quelle auf EnglischKanonische PrimärquellenOpenAI Codex Docs (öffnet in neuem Tab)

Offizielle Codex-Doku: App, CLI, IDE, Web, Integrationen und Automation.

Quelle auf EnglischKanonische PrimärquellenOpenAI Codex Skills (öffnet in neuem Tab)

Skills als wiederverwendbare Workflows mit SKILL.md, Scripts, References und Assets.

Quelle auf EnglischKanonische PrimärquellenOpenAI Codex Plugins (öffnet in neuem Tab)

Plugins als Distribution für Skills, Apps und MCP-Server im Codex-Ökosystem.

Quelle auf EnglischKanonische PrimärquellenOpenAI Codex Subagents (öffnet in neuem Tab)

Subagents für parallele Recherche, Umsetzung und Review in Codex.

Quelle auf EnglischMindset & MethodikKarpathy: Software Is Changing (Again) (öffnet in neuem Tab)

LLMs als neuer Computertyp („Software 3.0“), Autonomy-Slider, jagged intelligence.

Quelle auf EnglischMindset & MethodikWillison: Not all AI-assisted programming is vibe coding (öffnet in neuem Tab)

Begriffsklärung: Vibe Coding heißt kein Review vor Deploy.

Quelle auf EnglischMindset & MethodikWillison: Vibe engineering (öffnet in neuem Tab)

Die verantwortliche Version: Agent-Einsatz mit klarer Zuständigkeit.

Quelle auf EnglischMindset & MethodikBöckeler / Fowler: The role of developer skills in agentic coding (öffnet in neuem Tab)

Warum erfahrene Entwickler unverzichtbar bleiben.

Quelle auf EnglischMindset & MethodikPhilipp Schmid: The New Skill in AI is Context Engineering (öffnet in neuem Tab)

Oft zitierte Grundlagendefinition von Context Engineering.

Quelle auf EnglischPraktiker-Workflows & Spec-drivenHarper Reed: My LLM codegen workflow atm (öffnet in neuem Tab)

Der kanonische Brainstorm -> Spec -> Plan -> Execute-Workflow.

Quelle auf EnglischPraktiker-Workflows & Spec-drivengithub/spec-kit (öffnet in neuem Tab)

Open-Source-Toolkit für Spec-Driven Development: Spec -> Plan -> Tasks -> Implement.

Quelle auf EnglischPraktiker-Workflows & Spec-drivenThorsten Ball: How to Build an Agent (öffnet in neuem Tab)

Ein Coding-Agent ist im Kern „LLM + Loop + Tokens“, in unter 400 Zeilen Go gezeigt.

Quelle auf EnglischPraktiker-Workflows & Spec-drivenArmin Ronacher: Agentic Coding Recommendations (öffnet in neuem Tab)

Praxisempfehlungen: einfacher Code, schnelle Tools, Logging als Schlüssel zu Autonomie.

Quelle auf EnglischWerkzeug-LandschaftClaude Code (öffnet in neuem Tab)

Anthropics Terminal-/IDE-Agent; dichtes Ökosystem (Skills, Subagents, Hooks, MCP).

Quelle auf EnglischWerkzeug-LandschaftOpenAI Codex (öffnet in neuem Tab)

OpenAI-Ökosystem aus App, CLI, IDE, Skills, Plugins, MCP und Subagents.

Quelle auf EnglischWerkzeug-LandschaftAwesome Codex CLI (öffnet in neuem Tab)

Community-Landkarte für Codex-Tools; als Signal nutzen, nicht ungeprüft installieren.

Quelle auf EnglischWerkzeug-LandschaftCursor (öffnet in neuem Tab)

KI-nativer Editor mit Agent (Composer); bis zu 8 parallele Agents via Git-Worktrees.

Quelle auf EnglischWerkzeug-LandschaftAider (öffnet in neuem Tab)

Meistzitierter Open-Source-Terminal-Pair-Programmer, tief in Git integriert, modell-agnostisch.

Quelle auf EnglischWerkzeug-LandschaftGoogle Gemini CLI (öffnet in neuem Tab)

Quelloffen (Apache 2.0), 1M-Kontext, Google-Search-Grounding; gratis mit Google-Account.

Quelle auf EnglischWerkzeug-LandschaftJetBrains Research: Which AI Coding Tools Do Developers Actually Use? (öffnet in neuem Tab)

Survey-Daten aus über 10.000 Entwicklern. Neutraler Vergleich.

Quelle auf EnglischKurseClaude Code 101: Anthropic Academy (öffnet in neuem Tab)

Empfohlener Startpunkt, Einsteiger.

Quelle auf EnglischgratisKurseClaude Code: DeepLearning.AI × Anthropic (öffnet in neuem Tab)

Short Course (Elie Schoppik), Einsteiger bis Fortgeschritten.

Quelle auf EnglischgratisKurseClaude Code: Frontend Masters (öffnet in neuem Tab)

Von Anthropic-DX-Entwicklerin Lydia Hallie, fortgeschritten.

Quelle auf EnglischgratisKurseAgent Skills with Anthropic: DeepLearning.AI (öffnet in neuem Tab)

Wiederverwendbare Skills bauen, fortgeschritten.

Quelle auf EnglischgratisCommunities, Reports & StandardsDiscord: agenticbuilders.at (öffnet in neuem Tab)

Unsere Community: Fragen stellen, Fortschritte zeigen, ehrliche Einschätzungen bekommen.

Quelle auf DeutschCommunities, Reports & Standardsr/ClaudeAI (Reddit) (öffnet in neuem Tab)

Aktivste Claude-Code-Diskussion: Vergleiche, Prompts, Community-Tooling.

Quelle auf EnglischCommunities, Reports & StandardsAnthropic / Claude Discord (öffnet in neuem Tab)

Offizielle Community, direkter Austausch und Feedback-Kanäle.

Quelle auf EnglischCommunities, Reports & Standards2026 Agentic Coding Trends Report: Anthropic (öffnet in neuem Tab)

8 Entwicklungen, die SWE durch Coding-Agenten verändern, mit Case Studies.

Quelle auf EnglischCommunities, Reports & StandardsModel Context Protocol (MCP) (öffnet in neuem Tab)

Offener Standard („USB-C für KI“) zum Anbinden von Tools und Daten an LLM-Apps.

Quelle auf EnglischCommunities, Reports & StandardsAGENTS.md (öffnet in neuem Tab)

Maschinenlesbares Markdown-Manifest im Repo-Root, tool-übergreifend (Linux Foundation).

Quelle auf EnglischCommunities, Reports & Standardsllms.txt (öffnet in neuem Tab)

Vorschlag für eine /llms.txt, die LLMs ein sauberes Markdown-Inhaltsverzeichnis liefert.

Quelle auf Englisch
Schwester-ToolAus derselben Werkstatt: AgenticCutter

AgenticCutter ist unser Schwester-Tool für den Videoschnitt: Transkript rein, Füllwörter und Pausen raus, Schnitt freigeben, rendern und hochladen in einem Befehl.

AgenticCutter ansehen (öffnet in neuem Tab)

Glossar

18 Begriffe aufklappen
Agentic Coding
Arbeiten mit einem LLM, das in einer Schleife selbstständig handelt (lesen, editieren, ausführen, prüfen), unter menschlicher Aufsicht.
Agentischer Loop
Kontext sammeln -> planen -> handeln -> verifizieren -> wiederholen.
Vibe Coding
Code generieren lassen und laufen lassen, ohne ihn zu reviewen. Ok für Prototypen, riskant in Produktion.
Vibe Engineering
Verantwortlicher Agent-Einsatz: der Mensch bleibt accountable für das Ergebnis.
Context Engineering
Disziplin, dem Modell zur richtigen Zeit die richtigen (nicht möglichst viele) Tokens zu geben.
Context Rot
Qualitätsverfall, wenn der Kontext überfüllt oder verrauscht ist.
Delegation Gap
Lücke zwischen „KI berührt die Arbeit“ und „KI ist voll und sicher delegierbar“.
Spec-driven Development
Erst eine Spezifikation als ausführbares Artefakt, dann Plan, dann Implementierung.
Plan Mode
Modus, in dem der Agent erst einen Plan erstellt (und du ihn freigibst), bevor er ändert.
Subagent
Spezialisierter Hilfs-Agent mit eigenem Kontextfenster, für Recherche oder isolierte Verifikation.
Skill (SKILL.md)
On-demand-Paket aus Domänenwissen/Workflow, das der Agent bei Bedarf lädt.
Plugin
Installierbares Bündel aus Skills, App-Integrationen und MCP-Servern, mit dem ein Agent wiederverwendbare Workflows bekommt.
Connector
Vorgefertigte Anbindung an externe Dienste wie Google Workspace, Slack oder GitHub; je nach Produkt als App-Integration, MCP-Server oder Connector umgesetzt und separat authentifiziert.
MCP
Model Context Protocol: offener Standard, um Tools und Daten an Agenten anzubinden.
Hook
Shell-Befehl, der deterministisch an einem Lifecycle-Event feuert (z. B. Lint nach jedem Edit).
Headless Mode
Agent ohne interaktive UI (claude -p), für CI, Pre-Commit und Scripting.
Jagged Intelligence
LLMs sind in manchem übermenschlich, in scheinbar Einfachem unzuverlässig. Ein „zackiges“ Fähigkeitsprofil.
Autonomy Slider
Wie viel Leine man dem Agenten pro Aufgabe gibt: von eng kontrolliert bis weit autonom.

Zum Schluss

Diese Sammlung ist bewusst neutral und frei weitergebbar. Die Tool-Landschaft entwickelt sich schnell, Links werden gelegentlich gegengeprüft. Wenn du den ersten geführten Schritt willst: hol dir das Gratis-Handout.