Claude Code ist ein autonomer KI-gesteuerter Coding-Agent von Anthropic, der direkt im Terminal läuft und durch natürliche Sprache gesteuert wird. Im Gegensatz zu Autocomplete-Tools wie GitHub Copilot arbeitet Claude Code proaktiv und eigenständig: Es versteht ganze Projekte, liest und schreibt Dateien, erstellt Tests, führt Shell-Befehle und Git-Operationen aus und kommuniziert über das Model Context Protocol (MCP) mit externen Services wie Datenbanken, APIs und Issue-Trackern. Entwickler beschreiben eine Aufgabe in natürlicher Sprache, und Claude Code plant die Umsetzung, analysiert die Codebasis, schreibt den Code, führt Tests aus und erstellt Git-Commits – alles automatisch. Die Installation erfolgt über npm mit dem Befehl 'npm install -g @anthropic-ai/claude-code' und erfordert Node.js 18 oder höher. Claude Code unterstützt alle gängigen Programmiersprachen und läuft auf macOS, Linux und Windows (WSL2).

Wie unterscheidet sich Claude Code von GitHub Copilot?

Claude Code ist ein autonomer Agent, der ganze Aufgaben eigenständig erledigt – von der Dateianalyse über das Code-Schreiben bis zum Git-Commit. GitHub Copilot hingegen ist ein Autocomplete-Tool, das Inline-Code-Vorschläge innerhalb des Editors macht. Der entscheidende Unterschied liegt im Arbeitsumfang: Claude Code hat Zugriff auf das gesamte Projekt, kann Shell-Befehle ausführen, Tests starten, Git-Repositories verwalten und über MCP-Server mit externen Tools wie Datenbanken, GitHub, Jira und Slack kommunizieren. Copilot arbeitet primär innerhalb einer einzelnen Datei im Editor. Claude Code kann mehrstufige Aufgaben planen und ausführen, beispielsweise eine komplette Feature-Implementierung mit Tests, Dokumentation und Pull Request. Copilot schlägt einzelne Code-Zeilen oder Funktionen vor. Für einfache Code-Vervollständigung ist Copilot schneller, für komplexe Entwicklungsaufgaben bietet Claude Code deutlich mehr Autonomie und Projektverständnis.

Welche Abo-Modelle gibt es?

Der Claude Code Masterkurs bietet drei Abo-Modelle für jeden Bedarf: Das Monats-Abo kostet 24 EUR pro Monat und ist jederzeit flexibel kündbar – ideal zum Ausprobieren. Das Jahres-Abo kostet 229 EUR pro Jahr, was einer Ersparnis von 20 Prozent gegenüber der monatlichen Zahlung entspricht. Das Lifetime-Abo bietet für einmalig 499 EUR lebenslangen Zugriff auf alle Inhalte, einschließlich zukünftiger Updates und neuer Lektionen. Alle drei Modelle beinhalten den vollständigen Zugang zu allen 70 Lektionen von Grundlagen bis Experte, 43 Tools & Extensions Lektionen zu CLI-Werkzeugen und MCP-Servern, interaktive Quizzes zur Wissensüberprüfung, den Live-Playground zum Experimentieren, praktische Challenges und Community-Features wie Forum und Leaderboard. Der Kurs bietet außerdem eine kostenlose Vorschau der ersten Lektionen, sodass Interessierte den Kurs vor dem Kauf testen können.

Wie installiert man Claude Code?

Die Installation von Claude Code erfolgt in drei einfachen Schritten und dauert weniger als fünf Minuten. Zunächst muss Node.js in Version 18 oder höher installiert sein – dies ist die einzige Voraussetzung. Anschließend wird Claude Code global über npm installiert mit dem Befehl 'npm install -g @anthropic-ai/claude-code'. Nach der Installation navigiert man in ein beliebiges Projektverzeichnis und startet Claude Code mit dem Befehl 'claude'. Beim ersten Start wird man zur Authentifizierung aufgefordert: Entweder gibt man einen Anthropic API-Key ein oder nutzt die bequemere OAuth-Authentifizierung über die Anthropic Console im Browser. Claude Code läuft auf macOS, Linux und Windows, wobei für Windows die Nutzung von WSL2 (Windows Subsystem for Linux) empfohlen wird. Optional kann man eine CLAUDE.md Datei im Projektstamm erstellen, die Claude Code automatisch als Kontext für das jeweilige Projekt nutzt.

Was ist das Model Context Protocol (MCP)?

MCP (Model Context Protocol) ist ein offenes Protokoll von Anthropic, das Claude Code ermöglicht, sicher mit externen Tools und Services zu kommunizieren. Es funktioniert nach einem Client-Server-Modell: Claude Code ist der MCP-Client, und jeder externe Service wird über einen MCP-Server angebunden. Über MCP-Server kann Claude Code auf Datenbanken wie PostgreSQL und SQLite zugreifen, SQL-Abfragen ausführen und Schemas inspizieren. Es kann GitHub-Issues und Pull Requests verwalten, Jira-Tickets erstellen, Slack-Nachrichten senden und Brave Search für Web-Recherchen nutzen. Die Konfiguration erfolgt über eine JSON-Datei im Projekt oder global in den Claude Code Settings. Jeder MCP-Server definiert seine verfügbaren Tools, und Claude Code entscheidet eigenständig, wann welches Tool aufgerufen wird. Das Protokoll ist open-source und erweiterbar – Entwickler können eigene MCP-Server für beliebige APIs und Services schreiben und so die Fähigkeiten von Claude Code gezielt erweitern.

Was kostet Claude Code?

Claude Code selbst ist kostenlos als npm-Paket verfügbar. Die Nutzung erfordert jedoch einen Anthropic API-Key, und die Kosten richten sich nach dem tatsächlichen Tokenverbrauch. Claude Sonnet 4 kostet circa 3 US-Dollar pro Million Input-Tokens und 15 US-Dollar pro Million Output-Tokens – das ist das empfohlene Modell für die meisten Aufgaben. Claude Opus 4, das leistungsstärkere Modell für komplexe Aufgaben, kostet circa 15 US-Dollar pro Million Input-Tokens und 75 US-Dollar pro Million Output-Tokens. Ein typischer Entwicklungstag kostet je nach Nutzungsintensität zwischen 1 und 20 US-Dollar. Für Entwickler, die keine verbrauchsabhängige Abrechnung möchten, bietet Anthropic den Max Plan als monatliche Pauschale an. Damit erhält man ein festes Kontingent an Claude Code Nutzung pro Monat. Die Kosten lassen sich außerdem durch gezielte Nutzung der CLAUDE.md Datei und effizientes Prompt Engineering deutlich reduzieren.

Welche Programmiersprachen unterstützt Claude Code?

Claude Code ist vollständig sprachunabhängig und unterstützt alle gängigen Programmiersprachen, darunter Python, JavaScript, TypeScript, Rust, Go, Java, C++, C#, Ruby, PHP, Swift und Kotlin. Da Claude Code im Terminal arbeitet und nicht an eine bestimmte IDE gebunden ist, kann es mit jedem Projekt und jeder Sprache verwendet werden. Claude Code versteht nicht nur die Syntax, sondern auch die idiomatischen Patterns jeder Sprache – es schreibt pythonischen Python-Code, idiomatisches Rust mit korrektem Ownership, und typsicheres TypeScript. Besonders stark ist Claude Code bei Projekten mit mehreren Sprachen, etwa einem TypeScript-Frontend mit Python-Backend oder einem Go-Microservice mit SQL-Datenbank. Das Modell erkennt automatisch den verwendeten Tech Stack anhand der Projektdateien (package.json, Cargo.toml, pyproject.toml) und passt seine Code-Generierung entsprechend an. Auch Framework-spezifische Patterns wie React, Django, Rails oder Spring Boot werden korrekt angewendet.

Was ist eine CLAUDE.md Datei?

Die CLAUDE.md ist eine Markdown-Datei im Projektstamm, die Claude Code strukturierten Kontext über das jeweilige Projekt gibt. Sie funktioniert wie ein Briefing für den KI-Agenten und wird automatisch bei jedem Start von Claude Code eingelesen. Typische Inhalte sind eine Projektbeschreibung, die Architektur des Systems, verwendete Technologien und Frameworks, Coding-Konventionen wie Naming Standards und Formatierung, Build- und Test-Befehle sowie spezielle Anweisungen für den Umgang mit dem Code. Je detaillierter die CLAUDE.md, desto besser arbeitet Claude Code mit dem Projekt. Es gibt drei Ebenen von CLAUDE.md Dateien: die projektspezifische im Repo-Root, eine persönliche unter ~/.claude/CLAUDE.md für übergreifende Präferenzen, und optional Unterverzeichnis-spezifische CLAUDE.md Dateien für Module mit eigenen Konventionen. Best Practice ist, die CLAUDE.md mit dem Team zu teilen und im Git-Repository zu versionieren, damit alle Entwickler die gleiche KI-Erfahrung haben.

Claude Code überall & offizielle Ressourcen

Level 3 | 40 Minuten

Alle Nutzungsorte von Claude Code im Detail, die Dokumentationsstruktur verstehen, Extend-Features einordnen und einen nachhaltigen Lern-Workflow aufbauen.

Lernziele

Alle Nutzungsorte von Claude Code kennen und ihre Stärken/Grenzen verstehen
Die Dokumentationsstruktur von code.claude.com navigieren und die richtigen Kapitel finden
"Extend Claude Code" einordnen: CLAUDE.md, Skills, MCP, Subagents, Hooks, Plugins – mit Entscheidungshilfe
Einen nachhaltigen Workflow aufbauen: Kurs + Docs + Changelog + Community

Claude Code überall

Claude Code ist nicht nur ein Terminal-Tool. Es läuft auf mittlerweile acht verschiedenen Plattformen, jede mit eigenen Stärken. Die offizielle Übersicht findest du unter [Claude Code overview](https://code.claude.com/docs/en/overview) (Abschnitt „Use Claude Code everywhere"). Das Verständnis, WANN du WELCHE Plattform nutzt, ist entscheidend für einen effizienten Workflow.

Terminal (CLI) – das Kern-Erlebnis

Das Terminal ist die Ur-Form von Claude Code und bietet die vollständigste Funktionalität: - Volle Slash-Commands: /fast, /model, /rewind, /compact, /init, /agents, /hooks und alle weiteren. - MCP-Server: Alle MCP-Verbindungen (HTTP, SSE, stdio) funktionieren im Terminal. - Agent Teams: Nur im Terminal verfügbar (In-Process oder Split-Pane/tmux). - Headless/Programmatic Mode: Für CI/CD, Automatisierung und Scripting. - Pipe Support: Input und Output können gepiped werden – Unix-Philosophie. - Git Worktrees: Mehrere parallele Sessions in verschiedenen Worktrees. Wann Terminal? Immer wenn du die volle Kontrolle brauchst, mit Agent Teams arbeitest, in CI/CD-Pipelines oder bei fortgeschrittener Automatisierung.

# Terminal-Grundbefehle
claude                          # Interaktive Session starten
claude --model opus             # Mit bestimmtem Modell starten
claude --continue               # Letzte Session fortsetzen
claude --continue --fork-session # Session forken
claude --resume                 # Session-Picker öffnen

# Headless/Programmatic (für CI/CD)
echo "Review this PR" | claude --headless
claude -p "Fix all TypeScript errors" --output-format json

# Pipe-Support
cat error.log | claude "Was ist hier schiefgelaufen?"
claude "Generiere eine Migration" | tee migration.sql

Web (claude.ai/code) – keine Installation nötig

Die Web-Version läuft unter claude.ai/code und erfordert keine lokale Installation: - Parallele Tasks: Mehrere Claude-Code-Sessions gleichzeitig in verschiedenen Tabs. - Integrierte Diff-Ansicht: Code-Änderungen werden visuell als Diffs dargestellt. - Cloud-Sessions: Arbeit wird in der Cloud gespeichert, kein lokaler State. - Keine CLI-Kenntnisse nötig: Ideal für Einsteiger oder wenn du an einem fremden Rechner sitzt. Einschränkungen: Kein Zugriff auf lokale Dateien (alles in der Cloud), keine MCP-Server, keine Hooks, kein Agent Teams. Für lokale Projekte: CLI oder IDE-Extension.

Desktop-App – eigenständige Anwendung

Die Desktop-App ist eine eigenständige Anwendung mit grafischer Oberfläche: - Diffs und Inline-Edits: Visuelle Darstellung von Änderungen wie in einer IDE. - Parallele Sitzungen: Mehrere Sessions in Tabs, inkl. Git Worktree-Support. - Cloud-Sessions: Sessions können zwischen Desktop und Web synchronisiert werden. - Kein Terminal nötig: Für Nutzer, die lieber grafisch arbeiten. Wann Desktop? Wenn du eine dedizierte Claude-Code-Erfahrung willst ohne IDE-Integration, oder wenn du zwischen Projekten wechselst.

Chrome Extension (Beta) – Browser-Anbindung

Die Chrome-Extension verbindet Claude Code mit deinem Browser: - Web-Apps testen: Claude sieht was im Browser passiert und kann damit interagieren. - Console-Logs auslesen: Debugging von Frontend-Problemen direkt im Kontext. - Formulare ausfüllen, Daten extrahieren: Browser-Automatisierung. - Screenshots analysieren: Claude sieht die UI und kann über Design/Layout sprechen. Einschränkung: Beta-Status, Funktionsumfang kann sich ändern. Nicht geeignet für Backend-Arbeit.

VS Code Extension – die IDE-Integration

Die VS Code Extension bringt Claude Code direkt in den Editor. Offizielle Docs: [Use Claude Code in VS Code](https://code.claude.com/docs/en/vs-code). - Inline-Diffs: Änderungen werden direkt im Editor als Diff angezeigt – accept/reject pro Datei. - @-Erwähnungen: Referenziere Dateien und Ordner mit @-Syntax im Prompt. - Plan-Review: Plan Mode ist direkt in der Extension nutzbar. - Checkpoints: /rewind funktioniert auch in der Extension. - Multiple Conversations: Mehrere Sessions gleichzeitig. - Terminal-Integration: Du kannst zwischen Extension und CLI in VS Code wechseln. - MCP-Server: Werden aus deiner Konfiguration geladen. Wann VS Code? Wenn du sowieso in VS Code arbeitest und die inline Diffs und @-Erwähnungen nutzen willst. Für die meisten Entwickler ist das der tägliche Workflow.

JetBrains, CI/CD, Slack

JetBrains: Plugin für IntelliJ, PyCharm, WebStorm etc. Ähnlich zur VS Code Extension, aber für das JetBrains-Ökosystem.
GitHub Actions: @claude in PRs und Issues – Claude Code reviewed, kommentiert und erstellt Fixes direkt in GitHub. Headless-Modus.
GitLab CI/CD: Ähnlich zu GitHub Actions, integriert in GitLab-Pipelines.
Slack: Delegiere Tasks aus Slack an Claude Code im Web. Nützlich für Teams, die Slack als Kommunikationszentrale nutzen.

PLATTFORM-ENTSCHEIDUNGSHILFE
━━━━━━━━━━━━━━━━━━━━━━━━━━

Tägliche lokale Entwicklung?
  → VS Code Extension oder JetBrains Plugin

Volle Kontrolle, Agent Teams, MCP, Hooks?
  → Terminal (CLI)

Kein lokales Setup, schnell ausprobieren?
  → Web (claude.ai/code)

Dedizierte App ohne IDE?
  → Desktop-App

Frontend-Testing im Browser?
  → Chrome Extension (Beta)

CI/CD-Automatisierung?
  → GitHub Actions / GitLab CI/CD (Headless)

Team-Kommunikation integrieren?
  → Slack-Integration

EMPFEHLUNG FÜR DEN TÄGLICHEN WORKFLOW:
IDE-Extension + Terminal für Fortgeschrittenes
(80% IDE, 20% CLI für Agent Teams/MCP/Headless)

Dokumentationsstruktur: code.claude.com

Die zentrale und aktuellste Referenz ist code.claude.com. Die Docs sind in sechs Hauptbereiche gegliedert:

DOKUMENTATIONSSTRUKTUR – code.claude.com
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Getting started ─────────────────────────
  ├── Overview         → Was ist Claude Code?
  ├── Quickstart       → In 5 Minuten loslegen
  └── Changelog        → Neueste Features und Fixes

Core concepts ───────────────────────────
  ├── How Claude Code works → Agentic Loop, Tools,
  │                           Kontextfenster, Models
  ├── Extend Claude Code   → Wann CLAUDE.md, Skills,
  │                           MCP, Subagents, Hooks, Plugins
  ├── Common workflows     → Schritt-für-Schritt-Guides
  │                           (Bugs, Refactoring, Tests, etc.)
  └── Best practices       → Explore→Plan→Code, Kontext,
                              Verifizierung, CLAUDE.md

Outside of the terminal ─────────────────
  ├── Web, Desktop, Chrome
  ├── VS Code, JetBrains
  ├── GitHub Actions, GitLab CI/CD
  └── Slack

Build with Claude Code ──────────────────
  ├── Subagents, Agent Teams
  ├── Plugins (erstellen & installieren)
  ├── Skills, Output Styles
  ├── Hooks, Programmatic usage
  ├── MCP (Model Context Protocol)
  └── Troubleshooting

Deployment / Administration / Config ────
  ├── AWS, GCP, Azure
  ├── Teams & Enterprise Setup
  └── Settings, Permissions, Sandbox

Reference ───────────────────────────────
  ├── CLI reference
  ├── Interactive mode
  ├── Checkpointing
  ├── Hooks reference
  └── Plugins reference

Extend Claude Code – Entscheidungshilfe

Die Seite [Extend Claude Code](https://code.claude.com/docs/en/features-overview) erklärt die Erweiterungsoptionen. Hier eine Entscheidungshilfe, wann du welche Erweiterung brauchst:

WELCHE ERWEITERUNG FÜR WELCHEN ZWECK?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

"Claude soll meine Projekt-Konventionen kennen"
  → CLAUDE.md (persistenter Kontext, bei jeder Session geladen)

"Claude soll spezielle Workflows kennen, aber nur bei Bedarf"
  → Skills (bei Bedarf geladen, spart Kontext)

"Claude soll mit GitHub/Slack/Sentry/DB kommunizieren"
  → MCP-Server (verbindet externe Tools)

"Claude soll Teilaufgaben parallel erledigen"
  → Subagents (isoliert, ergebnisorientiert)

"Claude soll als Team an großen Aufgaben arbeiten"
  → Agent Teams (koordiniert, mit Kommunikation)

"Nach jedem Edit soll automatisch Prettier laufen"
  → Hooks (Event-basierte Automatisierung)

"Ich will alles bündeln und mit anderen teilen"
  → Plugins (Paket aus Skills, Hooks, MCP, Agents)

KONTEXTKOSTEN BEACHTEN:
  CLAUDE.md:   Bei jeder Session geladen → immer im Kontext
  Skills:      Nur bei Bedarf → spart Kontext
  MCP:         Tool-Beschreibungen im Kontext
  Subagents:   Eigenes Kontextfenster → entlastet deins
  Hooks:       Kein Kontext-Overhead (Shell-Scripts)
  Plugins:     Kombiniert alles → Kosten variieren

CLAUDE.md ist der Startpunkt – richte es für jedes Projekt ein. Die offiziellen Best Practices empfehlen: Kurze, menschenlesbare Anweisungen (nicht Beschreibungen). Bash-Befehle, Code-Style, Workflow-Regeln. Starte mit /init und verfeinere iterativ. Skills für domänenspezifisches Wissen, das nicht immer geladen sein muss. Portabel und wiederverwendbar zwischen Projekten. MCP für externe Tool-Anbindung. Populäre Server: GitHub, Slack, Sentry, PostgreSQL, Filesystem. Installation über HTTP, SSE oder stdio. Drei Scopes: lokal (Session), Projekt (.mcp.json), User (~/.claude). Subagents für fokussierte, parallele Aufgaben. Eigenes Kontextfenster, berichten zurück. Niedriger Token-Overhead. Hooks für Automatisierung ohne Kontext-Kosten. 8 Event-Typen: SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, TeammateIdle, TaskCompleted. Plugins bündeln alles: Skills, Agents, Hooks, MCP-Server, LSP. Installierbar aus Marketplaces oder als lokale Packages.

Wichtige Einstiegspunkte und Links

Übersicht (DE): [code.claude.com/docs/de/overview](https://code.claude.com/docs/de/overview)
Quickstart: Erste Schritte in wenigen Minuten
Changelog: [code.claude.com/docs/en/changelog](https://code.claude.com/docs/en/changelog) – regelmäßig prüfen!
How Claude Code works: Agentic Loop, Models, Tools, Kontext, Checkpoints, Permissions
Best practices: Verifizierung, Explore→Plan→Code, CLAUDE.md, Kontext-Management, Rewind
Common workflows: Codebase verstehen, Bugs fixen, Refactoring, Plan Mode, Sessions, Git Worktrees
Extend Claude Code: Wann CLAUDE.md, Skills, Subagents, Hooks, MCP, Plugins
MCP: [code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp)
CLI-Referenz: Alle Befehle und Flags
Settings: Konfiguration, Berechtigungen, Sandbox
Plugins & Skills: Erweiterungen erstellen und aus Marketplaces installieren

Nachhaltiger Lern-Workflow

Claude Code entwickelt sich schnell weiter. Ein nachhaltiger Lern-Workflow hilft dir, am Ball zu bleiben: 1. Changelog regelmäßig prüfen – Neue Features, Breaking Changes und Bugfixes werden dort dokumentiert. Mindestens einmal pro Woche. 2. Docs als Referenz nutzen – Du musst nicht alles auswendig wissen. Wenn du einen Hook konfigurieren willst, schlage die [Hooks reference](https://code.claude.com/docs/en/hooks) nach. Wenn du MCP einrichten willst, lies die [MCP-Docs](https://code.claude.com/docs/en/mcp). 3. CLAUDE.md iterativ verbessern – Jedes Mal wenn Claude einen Fehler macht, der auf fehlendem Kontext basiert, ergänze deine CLAUDE.md. Sie wird über Wochen immer besser. 4. Neue Features schrittweise ausprobieren – Nicht alles auf einmal aktivieren. Erst Skills, dann MCP, dann Hooks, dann Subagents, dann Agent Teams. Jedes Feature einzeln verstehen bevor du kombinierst. 5. Community und Ressourcen nutzen – r/ClaudeAI (450K+ Mitglieder), ClaudeLog.com (Mechanics und Best Practices), Anthropic Engineering Blog, GitHub-Repos mit Beispiel-Konfigurationen.

Updates und Installation

Claude Code wird laufend aktualisiert. Je nach Installationsmethode: - Native Install (empfohlen): Aktualisiert sich automatisch im Hintergrund. Keine Aktion nötig. - Homebrew: brew upgrade claude-code - WinGet: winget upgrade Anthropic.ClaudeCode Neue Slash-Commands, Fast Mode, Agent Teams, Checkpointing und Plugin-Features werden über Updates ausgerollt. Nach Updates: claude --version prüfen und Changelog lesen.

# Version prüfen
claude --version

# Homebrew Update
brew upgrade claude-code

# WinGet Update
winget upgrade Anthropic.ClaudeCode

# Changelog direkt aufrufen
# → code.claude.com/docs/en/changelog

llms.txt – der Dokumentations-Index

Für Automatisierung und LLMs bietet die Dokumentation einen vollständigen Seiten-Index unter https://code.claude.com/docs/llms.txt. Dort sind alle verfügbaren Docs-Seiten gelistet. Das ist nützlich für: - MCP-Server, die die Docs durchsuchen sollen - Eigene Scripts, die bestimmte Docs-Seiten abrufen - Schnelles Nachschlagen, wenn du den genauen URL einer Unterseite brauchst In deiner CLAUDE.md kannst du referenzieren: Offizielle Docs: https://code.claude.com/docs/llms.txt – so weiß Claude Code bei Bedarf, wo es nachschlagen kann.

# Dokumentations-Index für LLMs/Automatisierung
# Vollständiger Index: https://code.claude.com/docs/llms.txt
# Dort sind alle verfügbaren Seiten gelistet – ideal zum gezielten Nachschlagen.

# In CLAUDE.md referenzieren:
# ## Referenzen
# - Offizielle Claude Code Docs: https://code.claude.com/docs/llms.txt
# - Changelog: https://code.claude.com/docs/en/changelog

🎓 Kurs-Abschluss und nächste Schritte Gratulation! Du hast alle 30 Lektionen dieses Kurses durchgearbeitet – von den Grundlagen (Installation, CLAUDE.md, erste Befehle) über fortgeschrittene Workflows (Plan Mode, Skills, MCP, Hooks, Subagents) bis zu den neuesten Features (Fast Mode, Opus 4.6, Agent Teams, Checkpointing). Dieser Kurs vermittelt Konzepte, Workflows und Best Practices. Für exakte CLI-Syntax, aktuelle Flags und offizielle Empfehlungen ist code.claude.com die maßgebliche Quelle. Nutze beide: Kurs für Struktur und Verständnis; Docs für Referenz, Vertiefung und neueste Updates. Nächste Schritte: CLAUDE.md für dein Projekt einrichten (/init), einen MCP-Server anbinden, einen Subagent erstellen, Agent Teams ausprobieren. Viel Erfolg!