AI/Claude Code

Claude Code ist ein agentengestütztes Codierungswerkzeug von Anthropic, das Ihre Codebasis liest, Dateien bearbeitet, Befehle ausführt und sich nahtlos in Entwicklungs-Workflows (Terminal, VS Code, Browser, JetBrains etc.) integriert. Dieser Lernplan führt iterativ von der einfachen Installation bis hin zu fortgeschrittenen Themen wie MCP-Integration und benutzerdefinierten Skills.

1. Lernziele

• Grundlagen: Installation und Authentifizierung von Claude Code in verschiedenen Umgebungen (Terminal, IDE).
• Bedienung: Navigation in der Codebasis, Ausführen von komplexen Analysen, Ändern von Code und Beheben von Fehlern.
• Workflows: Einbindung in gängige Prozesse (Refactoring, Tests, Git-Integration, Pull Requests erstellen).
• Personalisierung: Arbeiten mit persistentem Kontext (`CLAUDE.md`), Auto-Memory und benutzerdefinierten Regeln (`.claude/rules/`).
• Erweiterung: Anpassung durch eigene Skills und Integration von Drittanbieter-Tools über das Model Context Protocol (MCP).

2. Lernpfad (Schritt-für-Schritt)

Modul 1: Grundlagen und Erste Schritte (Quickstart)

• Thema 1 - Installation: Wie man Claude Code installiert (z.B. via `brew install --cask claude-code` auf macOS, `winget` auf Windows oder Curl-Skript).
• Thema 2 - Login und Einrichtung: OAuth-Login, Anthropic Console, API-Keys und Abrechnung.
• Thema 3 - Erstes Projekt: Navigieren ins Projektverzeichnis (`cd your-project`) und Starten der CLI mittels des Befehls `claude`.
• Thema 4 - Basis-Interaktionen: Erste Fragen stellen, Code-Änderungen anweisen lassen, verstehen grundlegender Befehle (wie `/help`, `/clear` und `/compact`).

Modul 2: Häufige Workflows (Common Workflows)

• Thema 1 - Codebasis verstehen: Nutzung des "Plan Mode" für sichere Code-Analysen sowie des "Extended Thinking" (Thinking Mode), um komplexe Architekturen von fremden Repositories zu erfassen.
• Thema 2 - Debugging & Refactoring: Fehler finden und beheben, Code sicher refaktorieren und spezialisierte Subagents (`/subagent`) aufrufen.
• Thema 3 - Git & Versionskontrolle: Arbeiten mit Git: Commits mit aussagekräftigen Nachrichten erstellen lassen (`claude "commit my changes"`), Branches verwalten.
• Thema 4 - Paralleles Arbeiten: Parallele Sitzungen mit Git-Worktrees führen und Pipes im Terminal nutzen (z.B. `git diff | claude -p "Review this"`).

Modul 3: Projektwissen und Gedächtnis (Memory)

• Thema 1 - Projekt-Anweisungen: Erstellen und Nutzen einer `CLAUDE.md`-Datei im Root-Verzeichnis, um Projektstandards und Architekturvorgaben verbindlich festzulegen.
• Thema 2 - Auto-Memory: Verstehen, wie Claude sich selbstständig wichtige Projektdetails merkt, ohne dass diese manuell gepflegt werden müssen.
• Thema 3 - Management des Gedächtnisses: Den Befehl `/memory` zur Überprüfung des Gelernten nutzen. Strukturieren komplexerer Regeln über den Ordner `.claude/rules/`.

Modul 4: Erweiterung durch Skills und MCP

• Thema 1 - Skills (Benutzerdefinierte Befehle): Erfahren, wie man eigene Befehle bzw. Workarounds mit Frontmatter-Konfigurationen unter `.claude/skills/` anlegt. Argumente an Skills übergeben.
• Thema 2 - Model Context Protocol (MCP): Grundlagen zum MCP verstehen, um Claude Zugriff auf lokale Datenbanken, APIs oder Tools wie z.B. Sentry oder GitHub Code-Reviews zu geben.
• Thema 3 - MCP Server einrichten: Eine `.mcp.json` auf lokaler Ebene, Projektebene oder Nutzerebene einrichten (Stdio, SSE, Remote-HTTP) und Tools dynamisch updaten.

3. Konkreter Lernplan (Zeitplan)

| Woche | Fokus | Aufgaben / Praxis | |---------|---------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Woche 1 | Grundlagen & Setup | Claude Code (CLI oder VS Code/Cursor Extension) installieren. Einen Login durchführen. Eine einfache App (z.B. ToDo-App) modifizieren lassen. | | Woche 2 | Workflow-Integration | Claude Code in den eigenen Git-Workflow einbauen. Tests schreiben, Fehler fixen und Claude dazu bringen, einen Commit selbstständig zu verfassen. | | Woche 3 | Memory & Kontext | Eine umfassende `CLAUDE.md` für das aktuelle Hauptprojekt verfassen. Prüfen, wie Auto-Memory nach einigen Tagen Coding-Arbeit greift (`/memory`). | | Woche 4 | Tools und Erweiterung | Einen einfachen MCP-Server (z.B. Dateisystem) per `.mcp.json` anbinden. Einen eigenen Skill programmieren (z.B. `/review-pr` zur automatisierten Linting-Vorprüfung). |

4. Lernressourcen

Die offiziellen Dokumentationen von Anthropic dienen als primäre Lernressourcen.

Offizielle Dokumentation

• Übersicht / Erste Schritte
• Schnellstart-Leitfaden
• Häufige Workflows (Best Practices)
• Projektgedächtnis (CLAUDE.md & Auto-Memory)
• MCP – Claude mit externen Tools verbinden
• Claude mit eigenen Skills erweitern

CLI & App-Ressourcen

• Terminal-Befehle: Jederzeit über `claude --help` oder in der Sitzung über `/help` erreichbar.
• Desktop-App: Für visuelle Diff-Überprüfungen (verfügbar via `/desktop` im Terminal).
• Web-Zugriff: Arbeiten über claude.ai/code inkl. Remote Control.

5. Empfohlene Praxis-Projekte

1. Projekt A (Einsteiger): Bash-Skripte optimieren. Nutzen Sie den Terminal-Pipe-Workflow von Claude Code (z.B. `cat script.sh | claude -p ...`), um kleine Skripte zu verbessern oder sie plattformunabhängig zu machen.
2. Projekt B (Fortgeschritten): Eigene CLAUDE.md anlegen. Nehmen Sie ein bestehendes Open-Source-Projekt und definieren Sie detaillierte Anweisungen in einer `CLAUDE.md`. Lassen Sie Claude dann anhand dieser Regeln ein neues Feature (z.B. eine UI-Komponente) implementieren.
3. Projekt C (Experten): MCP Integration. Erstellen Sie eine `managed-mcp.json` Konfiguration, mit der Sie Claude Code mit Ihrer PostgreSQL Entwicklungs-Datenbank verbinden. Lassen Sie Claude im Anschluss Abfragen auf die Datenbank ausführen, um logische Datenfehler in Ihrem Code zu finden.