Git-Integration Profi

Level 2 | 35 Minuten

Meistere die vollständige Git-Integration von Claude Code

Lernziele

• Automatische Commits und PR-Erstellung beherrschen
• GitHub Actions mit Claude Code nutzen
• Code Reviews automatisieren
• Git-Workflows optimieren

Git Integration Overview

Claude Code wurde von Anfang an mit tiefer Git-Integration entwickelt — und das unterscheidet es fundamental von anderen KI-Coding-Tools. Während die meisten Assistenten nur Code generieren und du dich selbst um Versionskontrolle kümmern musst, versteht Claude Code den gesamten Git-Workflow und kann ihn automatisieren. Stell dir Claude Code als einen Entwickler vor, der nicht nur programmiert, sondern auch Git-Hygiene betreibt: sinnvolle Commits schreiben, Branches erstellen und verwalten, Pull Requests mit aussagekräftigen Beschreibungen anlegen, Code Reviews durchführen und sogar Merge-Konflikte lösen. Alles in natürlicher Sprache. Die Git-Integration arbeitet auf mehreren Ebenen. Auf der untersten Ebene hat Claude direkten Zugriff auf Git-Befehle über das Terminal. Auf einer höheren Ebene versteht Claude Git-Konzepte und kann komplexe Workflows orchestrieren. Und auf der höchsten Ebene integriert Claude mit GitHub, GitLab und anderen Plattformen über MCP Server oder die gh CLI. Besonders mächtig wird die Git-Integration in Kombination mit der GitHub CLI (gh). Wenn gh installiert und authentifiziert ist, kann Claude: Die Git-Historie durchsuchen ('Wer hat zuletzt das Payment-Modul geändert und warum?'), Issues analysieren und bearbeiten, Pull Requests erstellen und verwalten, Code Reviews durchführen und Kommentare posten, und sogar GitHub Actions Workflows triggern. Für Teams ist die Git-Integration besonders wertvoll: Durch Konventionen in der CLAUDE.md (Commit-Format, Branch-Naming, PR-Templates) stellst du sicher, dass alle Teammitglieder konsistente Git-Workflows haben — auch wenn Claude die Arbeit erledigt. Ein praktischer Hinweis: Claude Code respektiert deine .gitignore und versucht keine Dateien zu committen die nicht getrackt werden sollten. Sensible Dateien wie .env werden automatisch ausgeschlossen. Trotzdem solltest du vor jedem Push mit 'git diff --staged' prüfen was committed wird.

CLAUDE CODE GIT CAPABILITIES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📝 COMMITS
├── Intelligente Commit Messages
├── Conventional Commits Format
├── Multi-File Change Detection
└── Staged Changes Analysis

🔀 PULL REQUESTS
├── Automatische PR-Erstellung
├── PR Description Generation
├── Review Comment Responses
└── Merge Conflict Resolution

👀 CODE REVIEWS
├── @claude Review Trigger
├── Security Analysis
├── Style Check
└── Automated Suggestions

🤖 GITHUB ACTIONS
├── CI/CD Integration
├── Issue Automation
└── Deployment Triggers

Intelligente Commits

Intelligente Commits sind einer der beliebtesten Einsatzzwecke von Claude Code im Alltag. Claude analysiert deine Änderungen nicht nur syntaktisch — es versteht die ABSICHT hinter den Änderungen und generiert aussagekräftige Commit-Messages die dein Team auch in drei Monaten noch versteht. Der Unterschied zu einfachen Tools die nur den Diff lesen: Claude versteht den Kontext. Wenn du eine neue Validierungsfunktion hinzufügst und gleichzeitig den Aufruf in drei API-Routes einbaust, schreibt Claude nicht 'Modified validation.ts, route1.ts, route2.ts, route3.ts'. Stattdessen: 'Add email validation to user registration flow — validates format, checks disposable emails, and normalizes case before storage.' Claude kann verschiedene Commit-Konventionen einhalten. Conventional Commits (feat:, fix:, chore:), Gitmoji, JIRA-Ticket-Referenzen oder dein eigenes Format — definiere es in der CLAUDE.md und Claude hält sich daran. Zum Beispiel: 'PROJ-1234: feat(auth): implement email validation for registration endpoint.' Besonders nützlich ist die Fähigkeit, atomare Commits zu erstellen. Statt alle Änderungen in einen großen Commit zu packen, kann Claude die Änderungen logisch aufteilen: Erst die Validierungsfunktion committen, dann die Route-Änderungen, dann die Tests. Jeder Commit ist in sich geschlossen und kann unabhängig reviewed und reverted werden. Der Workflow ist simpel: Du sagst 'Committe die Änderungen' oder 'Erstelle sinnvolle Commits für die aktuellen Änderungen'. Claude analysiert den Diff, versteht die logischen Zusammenhänge, und schlägt Commits vor. Du bestätigst oder passt an. Ein Profi-Tipp: Sage Claude 'Erstelle die Commits, aber frage mich vor jedem Commit ob die Message passt'. So behältst du die Kontrolle ohne alles selbst schreiben zu müssen. Besonders wichtig bei Public Repositories wo die Commit-Historie für alle sichtbar ist.

# Claude analysiert Änderungen und erstellt Message
claude "Committe die aktuellen Änderungen"

# Mit spezifischem Format
claude "Committe mit Conventional Commits Format"

# Output:
# Analyzing changes...
# - Modified: src/auth/login.ts (42 lines)
# - Added: src/auth/types.ts (28 lines)
# - Modified: tests/auth.test.ts (15 lines)
#
# Suggested commit:
# feat(auth): implement JWT-based login system
#
# - Add login endpoint with JWT token generation
# - Create TypeScript interfaces for auth types
# - Add unit tests for login flow
#
# Proceed? [y/n/e(dit)]

# Commit Convention in CLAUDE.md definieren
# In CLAUDE.md:
# ## Git Conventions
# - Use Conventional Commits: feat:, fix:, docs:, etc.
# - Include ticket number: feat(auth): [PROJ-123] Add login

Pull Request Automation

Pull Requests sind der zentrale Qualitäts-Checkpoint in der modernen Softwareentwicklung — und Claude Code kann den gesamten PR-Workflow automatisieren. Von der Erstellung über die Beschreibung bis zum Review kann Claude jeden Schritt übernehmen oder unterstützen. Die einfachste Automation: Claude erstellt den PR für dich. Du sagst 'Erstelle einen PR für diesen Branch' und Claude nutzt die gh CLI um einen Pull Request zu erstellen. Dabei analysiert es alle Commits auf dem Branch, versteht die Gesamtänderung, und generiert eine aussagekräftige PR-Beschreibung mit Summary, Motivation, Änderungen, Test-Plan und Screenshots (falls relevant). Die PR-Beschreibung ist oft der Bereich wo Claude den größten Mehrwert liefert. Statt eine kurze Stichpunkt-Liste zu schreiben, generiert Claude eine strukturierte Beschreibung die dem Reviewer alles gibt was er braucht: Was wurde geändert und warum, welche Architekturentscheidungen wurden getroffen, welche Alternativen wurden erwogen, welche Tests existieren, und welche Bereiche besondere Aufmerksamkeit brauchen. Für Teams kannst du PR-Templates in der CLAUDE.md oder als Skill definieren. Damit folgen alle PRs dem gleichen Format, egal wer sie erstellt. Das beschleunigt Reviews erheblich weil Reviewer wissen wo welche Information steht. Besonders mächtig: Claude kann PRs auch reviewen. Sage 'Review den PR #42' und Claude analysiert den Diff, identifiziert potenzielle Probleme, und postet konstruktive Kommentare direkt auf dem PR. In Kombination mit GitHub Actions kann das vollautomatisch bei jedem neuen PR passieren. Claude kann auch auf Review-Feedback reagieren: 'Setze die Änderungen aus dem Review von @colleague um' — Claude liest die Kommentare, versteht die gewünschten Änderungen, implementiert sie und pushed die Updates. Ein Workflow-Tipp: Nutze Claude für die initiale PR-Erstellung und menschliche Reviews für die finale Qualitätskontrolle. Die Kombination aus KI-Effizienz und menschlichem Urteilsvermögen liefert die besten Ergebnisse.

# PR erstellen
claude "Erstelle einen PR für diese Änderungen"

# Claude wird:
# 1. Branch analysieren
# 2. Alle Commits zusammenfassen
# 3. PR Title + Description generieren
# 4. PR erstellen

# Mit spezifischem Target
claude "Erstelle PR gegen develop Branch"

# PR mit Template
claude "Erstelle PR mit unserem Standard-Template"

# Beispiel Output:
# Creating PR: feat/user-authentication → main
#
# Title: feat(auth): Add user authentication system
#
# ## Summary
# - Implements JWT-based authentication
# - Adds login/logout endpoints
# - Includes password hashing with bcrypt
#
# ## Changes
# - src/auth/* (new)
# - src/middleware/auth.ts (new)
# - tests/auth/* (new)
#
# ## Test Plan
# - [x] Unit tests added
# - [x] Integration tests pass
# - [ ] Manual testing on staging
#
# PR created: https://github.com/user/repo/pull/42

GitHub Actions Integration

Claude Code lässt sich nahtlos in GitHub Actions integrieren — die CI/CD-Plattform die direkt in GitHub eingebaut ist. Anthropic bietet eine offizielle GitHub Action (anthropics/claude-code-action), die speziell für automatische Code-Reviews bei Pull Requests entwickelt wurde. Aber die Möglichkeiten gehen weit darüber hinaus. Die offizielle Action installiert Claude Code in der CI-Umgebung, übergibt den PR-Diff als Kontext und lässt Claude ein Review durchführen. Das Ergebnis wird als PR-Kommentar gepostet. Die Einrichtung dauert weniger als 5 Minuten: Workflow-Datei erstellen, API-Key als Secret hinterlegen, und die Action in deinen PR-Workflow einbinden. Über Reviews hinaus kannst du Claude Code für jeden automatisierbaren Task in deiner Pipeline nutzen: Automatische Test-Generierung für neue Code-Dateien, Security-Scans die über einfaches Pattern-Matching hinausgehen, Release-Note Generierung aus Commit-History, Dependency-Updates mit automatischer Kompatibilitätsprüfung, oder Code-Quality-Checks die dein Linting ergänzen. Für jeden dieser Use Cases nutzt du den Headless Mode (-p Flag) in der GitHub Actions Workflow-Datei. Claude bekommt den Prompt, analysiert den Code, und gibt das Ergebnis aus. Mit --output-format json bekommst du strukturierte Daten für die Weiterverarbeitung. Wichtige Sicherheitshinweise für CI/CD: Nutze immer --max-turns um Endlosschleifen zu verhindern. Beschränke die erlaubten Tools mit --allowedTools auf das Minimum (meist reichen Read, Grep und Glob). Speichere API-Keys als GitHub Secrets, nie direkt im Workflow. Und nutze --dangerously-skip-permissions NUR in isolierten Container-Umgebungen. Die Kosten im Blick behalten: Jeder Pipeline-Lauf verbraucht Tokens. Bei aktiven Repositories mit vielen PRs pro Tag können sich die Kosten summieren. Nutze --max-turns und das günstigere Sonnet-Modell um die Kosten zu kontrollieren. Ein typischer Code-Review kostet etwa 0.02-0.05 USD.

# .github/workflows/claude-review.yml

name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-review:
    if: |
      github.event_name == 'pull_request' ||
      contains(github.event.comment.body, '@claude')
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          github_token: ${{ secrets.GITHUB_TOKEN }}

          # Optional: Custom Instructions
          claude_md: |
            Review this PR for:
            - Security vulnerabilities
            - Performance issues
            - Code style violations

          # Trigger on @claude mention
          trigger: "@claude"

          # Auto-review new PRs
          auto_review: true

Automated Code Review

Automatische Code Reviews sind der Killer-Use-Case für Claude Code in Teams. Statt auf einen menschlichen Reviewer zu warten, analysiert Claude den PR sofort und gibt detailliertes Feedback — oft innerhalb von 30 Sekunden nach dem Öffnen des PRs. Die Qualität von Claudes Reviews ist bemerkenswert: Es findet nicht nur offensichtliche Bugs, sondern auch subtile Probleme wie Race Conditions, fehlende Edge-Case-Behandlung, potenzielle Memory Leaks und inkonsistente API-Contracts. Gleichzeitig prüft es Code-Style, Naming-Konventionen und Dokumentation. Der Schlüssel zu guten automatischen Reviews ist der Kontext. Definiere in der CLAUDE.md genau welche Standards gelten: Code-Style-Regeln, Architektur-Patterns, Security-Anforderungen und Test-Konventionen. Je mehr Claude über eure Standards weiß, desto relevanter sind seine Findings. Ein gutes Setup kombiniert Claude-Reviews mit menschlichen Reviews: Claude übernimmt die erste Prüfung und filtert die offensichtlichen Probleme heraus. Der menschliche Reviewer kann sich dann auf architekturelle Fragen, Business-Logik und Design-Entscheidungen konzentrieren. Das spart dem Reviewer 30-50% der Review-Zeit. Besonders wertvoll sind automatische Reviews für Junior-Entwickler: Sie bekommen sofort konstruktives Feedback auf ihre PRs und lernen die Team-Standards kennen, ohne dass ein Senior jede Zeile prüfen muss. Die technische Umsetzung kann auf drei Wegen erfolgen: Erstens über die offizielle GitHub Action (anthropics/claude-code-action), zweitens über einen Custom GitHub Actions Workflow mit Headless Mode, drittens über die @claude Mention Integration (du installierst die Claude GitHub App und kannst Claude per @claude in PR-Kommentaren taggen). Ein Wort der Warnung: Automatische Reviews sollten menschliche Reviews ergänzen, nicht ersetzen. Claude kann Code-Qualität prüfen, aber nicht beurteilen ob ein Feature die Nutzer-Anforderungen richtig umsetzt oder ob die Architektur-Entscheidung langfristig sinnvoll ist.

@CLAUDE COMMANDS IN PRs
━━━━━━━━━━━━━━━━━━━━━━━

In einem PR-Kommentar:

@claude review this PR
→ Vollständiges Code Review

@claude check security
→ Security-fokussiertes Review

@claude explain changes
→ Erklärt alle Änderungen

@claude suggest improvements
→ Verbesserungsvorschläge

@claude fix lint errors
→ Behebt Lint-Fehler automatisch

@claude add tests
→ Generiert fehlende Tests

@claude update docs
→ Aktualisiert Dokumentation

ANTWORT BEISPIEL:
━━━━━━━━━━━━━━━━
## Code Review

### Security 🛡️
⚠️ Line 42: SQL query uses string concatenation
   → Use parameterized queries instead

### Performance ⚡
ℹ️ Line 78: Consider caching this API call

### Style 📝
✅ Follows project conventions

### Verdict
Request changes: 1 security issue needs fix

Git-Workflow Skill

Für wiederkehrende Git-Workflows wie Feature-Branch Erstellung, Release-Vorbereitung oder Hotfix-Prozesse lohnt sich ein dedizierter Git-Workflow Skill. Statt jedes Mal die gleichen Schritte manuell zu erklären, definierst du den Workflow einmal als Skill und rufst ihn dann mit einem Befehl auf. Ein Git-Workflow Skill enthält typischerweise: Die Konventionen für Branch-Naming (feature/TICKET-beschreibung, hotfix/beschreibung, release/v1.2.3), die Commit-Message-Standards (Conventional Commits, Ticket-Referenzen), den PR-Prozess (Branch erstellen, Commits machen, PR öffnen, Review anfordern), und die Release-Schritte (Version bumpen, Changelog aktualisieren, Tag erstellen). Der Skill kann auch projektspezifische Regeln enthalten: 'Alle Feature-Branches müssen von develop abzweigen'. 'Vor jedem Merge muss die CI-Pipeline grün sein'. 'Release-Branches müssen durch QA'. Diese Regeln sorgen dafür, dass Claude den Git-Workflow konsistent ausführt — auch wenn verschiedene Teammitglieder unterschiedlich arbeiten würden. Besonders nützlich ist ein Pre-Commit Abschnitt im Skill: 'Vor jedem Commit: Tests ausführen, Linting prüfen, Conventional Commit Format einhalten.' Das verhindert fehlerhafte Commits die später die Pipeline brechen. Der Skill kann auch Release-Automation enthalten: 'Bei einem Release: Version in package.json erhöhen, CHANGELOG.md aktualisieren (aus Commits seit dem letzten Release), Git-Tag erstellen, und Release-Notes generieren.' Claude führt diese Schritte automatisch aus und du musst nur noch bestätigen. Ein Praxis-Beispiel: Du tippst '/project:git-workflow feature PROJ-123 user-notification-preferences' und Claude erstellt den Branch mit dem korrekten Naming, setzt den richtigen Basis-Branch, und öffnet eine leere Commit-Message-Vorlage. Alles in unter 3 Sekunden.

# .claude/skills/git-workflow/SKILL.md

---
name: git-workflow
description: Standardisierter Git Workflow
invocation: user
triggers: ["commit", "pr", "push"]
---

# Git Workflow Skill

## Commit Flow

1. Status Check
   `bash
   git status
   git diff --staged
   `

2. Generate Message
   Format: <type>(<scope>): <description>

   Types:
   - feat: Neues Feature
   - fix: Bug Fix
   - docs: Dokumentation
   - style: Formatting
   - refactor: Code Restructure
   - test: Tests
   - chore: Maintenance

3. Commit
   `bash
   git commit -m "generated message"
   `

## PR Flow

1. Branch Check
   - Ensure on feature branch
   - Check remote sync

2. Generate PR
   - Title from commits
   - Body from template
   - Labels from changed files

Praktischer Workflow

Ein vollständiger Git-Workflow mit Claude Code im Alltag sieht so aus — vom ersten Commit bis zum gemergten PR. Dieses Beispiel zeigt dir den realistischen Ablauf den erfahrene Nutzer täglich praktizieren. Phase 1 — Feature starten: Du sagst Claude 'Erstelle einen Feature-Branch für Ticket PROJ-456: E-Mail-Benachrichtigungen bei Passwort-Änderung'. Claude erstellt den Branch (feature/PROJ-456-email-notification-password-change), wechselt dorthin, und ist bereit für die Implementierung. Phase 2 — Implementieren: Du beschreibst das Feature und Claude implementiert es. Während der Arbeit committet Claude logisch sinnvolle Zwischenstände: Erst das E-Mail-Template, dann den Service, dann die Route-Integration, dann die Tests. Jeder Commit hat eine aussagekräftige Message. Phase 3 — Review vorbereiten: Claude prüft die Gesamtänderung mit einem Self-Review, stellt sicher dass alle Tests grün sind, das Linting passt und keine Debug-Code übriggeblieben ist. Bei Problemen fixt Claude sie und committet die Fixes. Phase 4 — PR erstellen: Claude erstellt den PR mit einer detaillierten Beschreibung: Was wurde implementiert, warum, welche Architekturentscheidungen wurden getroffen, welche Tests existieren, und was der Reviewer besonders beachten sollte. Phase 5 — Feedback verarbeiten: Wenn Reviewer Änderungswünsche haben, sagst du Claude 'Setze das Review-Feedback von PR #456 um'. Claude liest die Kommentare, implementiert die Änderungen und pushed sie. Der Reviewer sieht die Updates automatisch. Phase 6 — Merge: Nachdem alle Reviews approved sind, kann Claude den Merge durchführen und den Feature-Branch löschen. Dieser gesamte Workflow dauert in der Praxis 10-20 Minuten statt 1-2 Stunden manueller Arbeit. Der größte Zeitgewinn liegt bei der PR-Beschreibung und der Verarbeitung von Review-Feedback.

# Kompletter Feature-Workflow mit Claude

# 1. Feature Branch erstellen
git checkout -b feat/user-dashboard

# 2. Mit Claude entwickeln
claude "Implementiere ein User Dashboard mit:
- Profil-Übersicht
- Activity Feed
- Settings Panel"

# Claude implementiert, du reviewst

# 3. Änderungen committen
claude "Committe die Änderungen"

# 4. Weitere Iteration
claude "Füge Unit Tests hinzu"
claude "Committe die Tests"

# 5. PR erstellen
claude "Erstelle PR gegen main"

# 6. Review-Feedback einarbeiten
# (Reviewer kommentiert, du sagst Claude)
claude "Adressiere das Feedback zum Error Handling"

# 7. Final Merge
# (Nach Approval)
claude "Squash und merge den PR"

⚠️ Git Safety Claude Code ist vorsichtig mit Git: Automatisch blockiert: - Force Push ohne Bestätigung - Push zu main/master direkt - Löschen von Remote Branches Immer mit Bestätigung: - Jeder Commit - Jeder Push - PR Creation Best Practice: Nutze Branch Protection Rules auf GitHub!

Zusammenfassung

• ✅ Commits: Intelligente Messages mit Conventional Commits
• ✅ PRs: Automatische Erstellung mit Summary
• ✅ Reviews: @claude in PR-Kommentaren
• ✅ GitHub Actions: CI/CD Integration
• ✅ Workflows: Custom Git-Skills erstellen
• ✅ Safety: Built-in Schutz vor gefährlichen Operationen