Claude Code Schulung für Entwickler: vom Prompt zum Agenten

Claude Code verstehen und professionell einsetzen

• Claude Code als agentisches Entwicklungswerkzeug: lesen, ändern, ausführen, prüfen im Agentic Loop
• Chatbot, Coding-Assistent und Coding-Agent: Unterschiede bei Kontext, Werkzeugen und Verantwortung
• Installation per nativem Installer, Anmeldung, Abomodell oder API-Schlüssel und Grundkonfiguration
• Claude Code im Terminal, als Erweiterung für VS Code und JetBrains-IDEs und in der Desktop-App
• Modelle mit /model wählen: leistungsstarkes Modell für Planung, schnelles Modell für Routinearbeit
• Sessions verstehen: fortsetzen mit --continue und --resume, je Session eine abgegrenzte Aufgabe
• Wichtige Slash-Befehle, Tastenkürzel und Einstellungen: /help, /config, Shift+Tab, Esc
• Typische Einsatzszenarien: Codebasis erkunden, Fehler eingrenzen, Refactoring, Tests, Migrationen
• Claude Code im Browser und in der Cloud-Umgebung: Aufgaben aus GitHub-Repositorys starten (Überblick)

Vom Prompt zum Entwicklungsauftrag in Claude Code

• Warum klassisches Prompt Engineering beim Coding nicht reicht: der Agent handelt, statt nur zu antworten
• Aufgaben als Entwicklungsauftrag formulieren: Ziel, betroffene Stellen im Code, erwartetes Ergebnis
• Anforderungen, Constraints und Akzeptanzkriterien im Auftrag festhalten
• Bestehenden Code als Kontext einbeziehen: Dateien mit @ referenzieren, Vorbilder im Projekt nennen
• Große Aufgaben in kontrollierbare, einzeln prüfbare Arbeitsschritte zerlegen
• Mit Spezifikationen als Markdown-Datei statt mit spontanen Einzelprompts arbeiten
• Fehlinterpretationen reduzieren: Annahmen offenlegen und Rückfragen ausdrücklich zulassen
• Wiederverwendbare Auftragsmuster für Entwicklungsprojekte als eigene Slash-Befehle ablegen
• Screenshots, Stacktraces und Logauszüge gezielt als Kontext in den Auftrag geben
• Prüfweg mitliefern: welcher Testbefehl oder welche Ausgabe beweist, dass die Aufgabe erledigt ist

Context Engineering für komplexe Codebasen in Claude Code

• Kontext als knappe Ressource: was das Kontextfenster füllt und wie es die Ergebnisqualität beeinflusst
• Relevanten von irrelevantem Projektkontext unterscheiden: gezielt lesen lassen statt alles laden
• Sessions und Kontextfenster bewusst verwalten: Auslastung mit /context prüfen, /clear zwischen Aufgaben
• Compaction verstehen: automatische Verdichtung und /compact mit eigenen Hinweisen zum Behalten
• Projektwissen dauerhaft verfügbar machen: CLAUDE.md, Architekturdokumente und Notizen im Repository
• Kontext für längere Aufgaben strukturieren: Fortschritt in Plan- und TODO-Dateien festhalten
• Informationsüberlastung und Context Drift erkennen und mit frischer Session gegensteuern
• Große Repositories und gewachsene Anwendungen: Einstiegspunkte, Modulgrenzen, Erkundung per Subagent
• MCP-Server und Werkzeugdefinitionen als Kontextverbraucher: nur benötigte Server aktivieren

CLAUDE.md als Gedächtnis des Projekts

• Claude-Projekte mit /init initialisieren und die erzeugte CLAUDE.md kritisch überarbeiten
• Aufbau und Aufgabe einer CLAUDE.md: kurz, konkret, zu Beginn jeder Session geladen
• Architekturregeln und Schichtgrenzen dokumentieren
• Coding Standards und Projektkonventionen hinterlegen, Beispiele statt Prosa
• Build-, Test- und Deployment-Regeln mit exakten Befehlen festlegen
• Projektwissen von konkreten Aufgaben trennen: Dauerregeln in die CLAUDE.md, Details in den Auftrag
• CLAUDE.md und automatische Memory-Funktion (Auto Memory) unterscheiden, Inhalte mit /memory pflegen
• Wartbare Projektanweisungen für Teams: Benutzer-, Projekt- und Unterverzeichnisebene, Review im Repository
• Große Anweisungen aufteilen: @-Importe und Regeln mit Pfadbezug in .claude/rules/

Plan Mode und Spec Driven Development in Claude Code

• Komplexe Aufgaben zunächst analysieren statt sofort programmieren: Codebasis erst lesen lassen
• Plan Mode gezielt einsetzen: per Shift+Tab umschalten, Plan prüfen und ausdrücklich freigeben
• Anforderungen in technische Umsetzungsschritte übersetzen
• Architekturentscheidungen vor der Implementierung prüfen und Alternativen vergleichen lassen
• Abhängigkeiten und Risiken erkennen: betroffene Module, Datenmigrationen, öffentliche Schnittstellen
• Pläne iterativ verbessern: Plan kommentieren, ändern und erneut vorlegen lassen
• Umsetzung gegen die Spezifikation kontrollieren: Plan, Diff und Akzeptanzkriterien abgleichen
• Planen und Implementieren bewusst trennen: Plan als Datei sichern, Umsetzung in frischer Session
• Spec-Driven Development: Anforderungen, Entwurf und Aufgabenliste als versionierte Markdown-Dateien
• Erweitertes Nachdenken für schwierige Entwurfsfragen gezielt anfordern, für Routine weglassen

Claude Code Tools und kontrollierte Autonomie

• Integrierte Werkzeuge verstehen: Lesen, Bearbeiten, Suchen, Shell, Web-Abruf und Websuche
• Dateien analysieren, erzeugen und verändern lassen und jeden Diff nachvollziehen
• Terminalbefehle kontrolliert ausführen lassen: Freigabe je Befehl oder dauerhaft für sichere Befehle
• Entwicklungswerkzeuge in agentische Abläufe integrieren: Linter, Formatter, Testrunner, gh-CLI
• Permissions sinnvoll konfigurieren: allow-, ask- und deny-Regeln in settings.json und /permissions
• Permission-Modi im Vergleich: Manual (default), acceptEdits, Plan Mode, Auto-Modus mit Klassifikator, dontAsk, bypassPermissions
• Risiken autonomer Aktionen einschätzen: Löschen, Netzwerkzugriff, Paketinstallation, Push
• Änderungen überprüfen und rückgängig machen: Checkpoints und /rewind
• Versionskontrolle als Sicherheitsnetz für KI-Entwicklung: kleine Commits, Branches, Git-Worktrees

Subagents in Claude Code für spezialisierte Entwicklungsaufgaben

• Das Konzept spezialisierter KI-Agenten: eigener Kontext, eigene Werkzeuge, eigener Systemprompt
• Aufgaben sinnvoll an Subagents delegieren und eingebaute Subagents für Erkundung und Planung nutzen
• Eigene Subagents als Markdown-Datei in .claude/agents/ anlegen oder von Claude erstellen lassen
• Rollen und Verantwortungsbereiche über Beschreibung, Werkzeugliste und Modell festlegen
• Kontext zwischen Hauptagent und Subagent strukturieren: präziser Auftrag hinein, Zusammenfassung zurück
• Recherche, Analyse, Testing und Review an spezialisierte Subagents delegieren
• Mehrere Agenten innerhalb eines Entwicklungsprozesses koordinieren: parallel oder nacheinander
• Grenzen und typische Fehler von Multi-Agent-Workflows: verlorener Kontext, Doppelarbeit, Kosten
• Ausblick: Architektur von Multi-Agenten-Systemen vertieft das Seminar Claude Code Intensiv

Claude Code Agent Skills entwickeln und wiederverwenden

• Skills als wiederverwendbare Fähigkeiten: Ordner mit SKILL.md, Skripten und Referenzdateien
• Unterschied zwischen Instruktionen, Skills und Subagents: was wann in den Kontext geladen wird
• Eigene Agent Skills erstellen: Frontmatter mit Name und Beschreibung, Anleitung, Hilfsskripte
• Wiederkehrende Entwicklungsprozesse als Skill standardisieren
• Skills für Testing, Dokumentation und Code Reviews entwickeln
• Projektbezogene Skills in .claude/skills/ und globale Skills im Benutzerverzeichnis unterscheiden
• Skills mit bestehenden Workflows kombinieren: Aufruf per Slash-Befehl oder automatisch über die Beschreibung
• Eine persönliche Claude Code Toolbox aufbauen und versionieren
• Beschreibungen so formulieren, dass ein Skill zuverlässig und nicht zu oft ausgelöst wird

Claude Code mit MCP erweitern

• Model Context Protocol verständlich erklärt: Client, Server, Werkzeuge, Ressourcen, Prompts
• Architektur und Aufgabe von MCP-Servern: lokale Prozesse über stdio und entfernte Server über HTTP
• Externe Tools und Datenquellen anbinden: Issue-Tracker, Datenbank, Browser, Fachdokumentation
• Claude Code zusätzliche Fähigkeiten bereitstellen: Werkzeuge, Ressourcen per @, MCP-Prompts als Befehle
• MCP-Server mit claude mcp add konfigurieren, mit /mcp testen und per OAuth anmelden
• Berechtigungen und Sicherheitsgrenzen: Gültigkeitsbereiche lokal, Projekt (.mcp.json) und Benutzer
• Geeignete MCP-Integrationen auswählen: Nutzen gegen Kontextverbrauch und Risiko abwägen
• Eigene Erweiterungsszenarien konzipieren: kleiner MCP-Server für eine interne API
• Claude Code selbst als MCP-Server für andere Anwendungen bereitstellen (claude mcp serve)

Hooks, Plugins und automatisierte Workflows in Claude Code

• Hooks als Ereignismechanismus: deterministische Regeln statt Bitten im Prompt
• Aktionen vor und nach Werkzeugaufrufen ausführen: PreToolUse und PostToolUse
• Qualitätsprüfungen automatisieren: Formatter und Linter nach jeder Dateiänderung
• Tests und Validierungen integrieren: Stop-Hook verlangt grüne Tests vor dem Abschluss
• Weitere Ereignisse nutzen: UserPromptSubmit, SessionStart, Notification
• Plugins: Skills, Subagents, Hooks und MCP-Server gebündelt, Marktplätze mit /plugin
• Wiederkehrende Abläufe standardisieren und als Plugin im Team teilen
• Automatisierung und menschliche Kontrolle ausbalancieren: welche Freigaben beim Menschen bleiben
• Eigene Claude Code Workflows entwerfen: Skill, Hook und Subagent kombinieren
• Nicht interaktiv mit claude -p in Skripten und CI – Überblick, Vertiefung im Seminar Claude Code Intensiv

Sicher mit autonomen Coding Agents arbeiten

• Permission Management: Regeln je Werkzeug und Muster für Benutzer, Projekt und Organisation
• Native Sandbox für Shell-Befehle verstehen: Dateisystem- und Netzwerkisolation mit /sandbox
• Claude Code in isolierten Umgebungen ausführen: Dev Container und virtuelle Maschinen
• Docker Sandboxes als zusätzliche Schutzschicht einsetzen
• Kritische Befehle und sensible Ressourcen absichern: deny-Regeln für .env, Schlüssel und Produktionszugänge
• Git für kontrollierbare KI-Änderungen nutzen: Branch je Auftrag, Review vor dem Merge
• Agentenergebnisse systematisch überprüfen: Diff, Tests, Checkliste für Sicherheit und Architektur
• Sicherheitsgrenzen für produktive Umgebungen: getrennte Zugangsdaten, kein Produktivzugriff
• Rückfragen komplett abschalten (--dangerously-skip-permissions) nur in isolierter Umgebung

Agentische Entwicklung mit Loops in Claude Code

• Iterative Agentenschleifen verstehen: planen, ändern, prüfen, wiederholen
• Aufgaben automatisch planen, ausführen und überprüfen lassen
• Ralph Loops als Entwicklungsprinzip: derselbe Auftrag wiederholt, Fortschritt in einer Datei
• Fortschritt über mehrere Iterationen steuern: Statusdatei, ein Commit je Iteration
• Tests und Akzeptanzkriterien als Feedbackmechanismus einsetzen
• Abbruchbedingungen definieren: Zielkriterium, maximale Iterationen, Zeit- und Kostenlimit
• Fehlentwicklungen und Endlosschleifen vermeiden: wiederholte gleiche Lösungsversuche erkennen
• Geeignete Aufgaben für autonome Bearbeitung auswählen: Migrationen, Testabdeckung, mechanische Umbauten
• Wiederkehrende Prüfungen in festen Intervallen mit /loop ausführen

Claude Code im eigenen Repository absichern: Grenzen, Fremdinhalte, Kosten

• Startmodus je Repository wählen: Plan Mode für fremden Code, automatische Annahme nur im Feature-Branch
• Prompt Injection über MCP-Server und Web-Abruf: Anweisungen in Issues, READMEs und Webseiten sind Daten
• PreToolUse-Hook als Leitplanke: Push auf main und Löschbefehle außerhalb des Projekts blockieren
• Fremde Plugins und Skills vor der Installation lesen – deren Hooks und Skripte laufen mit Ihren Rechten
• Verbrauch von Claude Code je Session beobachten: Modellwahl, Kontextgröße und Subagents als Kostenhebel

Praxisprojekt: Warteliste für die Platzvergabe einer Kita – von der Anforderung zum fertigen Feature

• Ausgangssituation und Anforderungen analysieren: Anmeldungen, Wunschtermine, Geschwisterregel, Prioritäten
• Projektkontext vorbereiten: die bestehende Kita-Verwaltung von einem Subagent erkunden lassen
• CLAUDE.md der Anwendung erstellen oder optimieren
• Technische Spezifikation der Warteliste entwickeln: Datenmodell, Ranglogik, Benachrichtigungen
• Umsetzung mit Plan Mode vorbereiten und den Plan gegen die Spezifikation prüfen
• Teilaufgaben an Subagents delegieren: Datenbankmigration, Oberfläche, Testfälle
• Skills und Tools gezielt einsetzen: Test-Skill, Formatter-Hook, MCP-Zugriff auf das Ticket
• Implementierung testen, überprüfen und verbessern
• Änderungen mit Git nachvollziehbar absichern: Branch, Commits, Pull-Request-Beschreibung
• Den gesamten Workflow gemeinsam reflektieren: was lief autonom, wo war Eingreifen nötig?

Lernziele

• Sie formulieren Entwicklungsaufträge mit Constraints, Akzeptanzkriterien und Prüfweg, die Claude Code ohne Rätselraten umsetzen kann
• Sie pflegen eine CLAUDE.md mit Architekturregeln, Konventionen und Testbefehlen und halten das Kontextfenster mit /context, /clear und /compact im Griff
• Sie trennen Planung und Umsetzung mit Plan Mode und Spezifikationsdateien und prüfen den Diff gegen die Spezifikation
• Sie konfigurieren Permission-Modi, allow- und deny-Regeln und die Sandbox passend zum Risiko der Aufgabe
• Sie erstellen eigene Subagents und Skills, binden MCP-Server ein und automatisieren Prüfungen mit Hooks
• Sie setzen Loops mit Abbruchbedingungen ein und wählen Aufgaben aus, die sich für autonome Bearbeitung eignen

Zielgruppe

• Entwickler:innen, die Claude Code im Alltag einsetzen und vom Assistenten zum geführten Agenten wechseln wollen
• Tech Leads, die Projektregeln, Rechte und Erweiterungen für Claude Code in ihrem Repository festlegen
• Voraussetzungen: sicherer Umgang mit Git, Terminal und einer Programmiersprache; ein Claude-Abo oder API-Zugang