Der ultimative CLAUDE.md-Leitfaden: So verzehnfachen Sie Ihre Claude-Code-Produktivität

Was eine CLAUDE.md-Datei ist und warum sie zählt

Wenn Sie Claude Code ohne CLAUDE.md-Datei nutzen, lassen Sie den Großteil seiner Power liegen.

CLAUDE.md ist eine Markdown-Konfigurationsdatei, die Claude Code automatisch zu Beginn jeder Session liest. Sie informiert Claude über die Architektur Ihres Projekts, Coding-Standards, bevorzugte Tools, Test-Muster und Workflow-Regeln. Statt dieselben Anweisungen in jedem Gespräch zu wiederholen, schreiben Sie sie einmal, und Claude folgt ihnen jedes Mal.

Stellen Sie sich den Unterschied vor zwischen der Einstellung eines Auftragnehmers, der nichts über Ihre Firma weiß, und einem, der Ihr gesamtes Engineering-Handbuch gelesen hat. Die CLAUDE.md-Datei ist dieses Handbuch.

Warum CLAUDE.md wiederholtes Prompting schlägt

Die Token-Einsparungen allein sind erheblich. Wenn Sie pro Gespräch 500 Tokens fürs Kontextsetzen ausgeben und 20 Gespräche pro Tag haben, sind das 10.000 Tokens täglich — oder grob 0,15–0,75 $ pro Tag je nach Modell. Über einen Monat spart eine CLAUDE.md-Datei 4,50–22,50 $ an reinen API-Kosten und liefert dabei bessere Ergebnisse.

Anthropic-Credits | AWS-Credits | Google-Cloud-Credits

---

Wie Claude Code CLAUDE.md-Dateien liest

Claude Code sucht nach CLAUDE.md-Dateien in einer spezifischen Priorisierungsreihenfolge. Diese Hierarchie zu verstehen ist essenziell, um Ihre Anweisungen effektiv zu organisieren.

Reihenfolge beim Laden der Dateien

Claude Code merged alle relevanten Dateien. Wenn Ihre globale Datei "verwende 2-Space-Einrückung" sagt, aber Ihre Projektdatei "verwende 4-Space-Tabs" sagt, gewinnt für dieses Projekt die Projektdatei.

Was wohin gehört

Globale CLAUDE.md (~/.claude/CLAUDE.md) — Präferenzen, die überall gelten:

# Global Preferences
- Always use TypeScript over JavaScript when possible
- Prefer functional components over class components in React
- Write concise commit messages under 72 characters
- Use ESM imports, never CommonJS require()

Projekt-CLAUDE.md (Projekt-Root) — alles, was spezifisch für dieses Codebase ist:

# Project: Acme Dashboard
## Tech Stack
- Next.js 15 with App Router
- TypeScript 5.x strict mode
- Tailwind CSS 4.0
- Prisma ORM with PostgreSQL
- Jest + React Testing Library for tests

## Architecture
- /app — Next.js routes (App Router only, no Pages Router)
- /components — reusable UI components
- /lib — business logic and utilities
- /prisma — database schema and migrations

---

Ihre erste CLAUDE.md-Datei erstellen

Hier ist ein Schritt-für-Schritt-Setup, um mit Claude Code und einer richtig konfigurierten CLAUDE.md-Datei zu starten.

Schritt 1: Claude Code installieren

npm install -g @anthropic-ai/claude-code

Schritt 2: CLAUDE.md im Projekt-Root erstellen

touch CLAUDE.md

Schritt 3: Basis-Konfiguration hinzufügen

Starten Sie mit diesem minimalen Template und erweitern Sie nach Bedarf:

# Project: [Your Project Name]

## Tech Stack
- [Language/Framework]
- [Database]
- [Key libraries]

## Coding Standards
- [Indentation preference]
- [Naming conventions]
- [Import ordering]

## Rules
- Always write tests for new functions
- Never commit directly to main
- Use conventional commit messages

Schritt 4: Claude Code ausführen

claude

Claude Code erkennt und lädt Ihre CLAUDE.md-Datei automatisch. Sie sehen eine Bestätigung im Session-Output.

---

CLAUDE.md-Templates: Starter, Advanced und Team

Template 1: Einfaches Projekt (20 Zeilen)

Am besten für Solo-Entwickler, Side-Projects und kleine Codebases.

# My App

## Stack
- Python 3.12, FastAPI, SQLAlchemy, PostgreSQL
- pytest for testing

## Rules
- Use type hints on all function signatures
- Write docstrings for public functions
- Keep functions under 30 lines
- Use async/await for all database operations
- Format with black, lint with ruff

## Patterns
- Repository pattern for data access
- Pydantic models for request/response validation
- Dependency injection via FastAPI Depends()

Template 2: Fortgeschrittenes Full-Stack-Projekt (80+ Zeilen)

Für Produktionsanwendungen mit mehreren Entwicklern und komplexer Architektur.

# Acme SaaS Platform

## Tech Stack
- Frontend: Next.js 15, TypeScript 5.x, Tailwind CSS 4.0
- Backend: Node.js 22, tRPC, Prisma ORM
- Database: PostgreSQL 16, Redis 7
- Infrastructure: Vercel (frontend), Railway (backend)
- Testing: Vitest, Playwright, MSW

## Architecture
All code follows Clean Architecture principles:
- /packages/web — Next.js frontend (App Router only)
- /packages/api — tRPC backend
- /packages/shared — shared types and utilities
- /packages/db — Prisma schema and client

## Coding Standards
- Strict TypeScript: no any, no ts-ignore
- All components must be functional with hooks
- Server Components by default, "use client" only when needed
- All API routes must have Zod input validation
- Database queries go through repository layer, never raw SQL

## Testing Requirements
- Minimum 80% coverage for new code
- Unit tests for all business logic
- Integration tests for API endpoints
- E2E tests for critical user flows
- Use MSW for API mocking, never mock fetch directly

## Git Workflow
- Conventional commits: feat:, fix:, chore:, docs:
- All PRs require passing CI before merge
- Squash merge to main
- Branch naming: feature/TICKET-123-description

## Security Rules
- NEVER hardcode secrets or API keys
- Always use environment variables for config
- Sanitize all user input
- Use parameterized queries (Prisma handles this)
- NEVER expose internal error details to clients

Template 3: Team-Konfiguration (über Git geteilt)

Für Teams, die konsistentes Claude-Code-Verhalten über alle Mitglieder hinweg wollen.

# Team Engineering Standards — Acme Corp

## Overview
This file ensures Claude Code follows our team's engineering
standards. Committed to Git so all engineers get identical behavior.

## Code Review Checklist (Claude must follow before suggesting code)
1. Does this change have tests?
2. Are error cases handled?
3. Is the function documented?
4. Does it follow our naming conventions?
5. Are there any security implications?

## Naming Conventions
- Components: PascalCase (UserProfile.tsx)
- Hooks: camelCase with use prefix (useAuth.ts)
- Utils: camelCase (formatDate.ts)
- Constants: SCREAMING_SNAKE (MAX_RETRIES)
- Database tables: snake_case (user_profiles)
- API routes: kebab-case (/api/user-settings)

## Forbidden Patterns
- DO NOT use console.log in production code (use our logger)
- DO NOT use any TypeScript escape hatches (any, @ts-ignore)
- DO NOT install new dependencies without justification
- DO NOT modify database schema without migration file
- DO NOT use default exports (use named exports only)

## Preferred Libraries (do not suggest alternatives)
- State management: Zustand (not Redux)
- Forms: React Hook Form + Zod (not Formik)
- HTTP client: native fetch (not Axios)
- Date handling: date-fns (not Moment.js)
- Animation: Framer Motion (not React Spring)

---

Vergleich: CLAUDE.md vs. .cursorrules vs. .github/copilot-instructions.md

Wenn Sie AI-Coding-Tools evaluieren, ist es entscheidend zu verstehen, wie jedes mit Konfiguration umgeht.

Der Schlüsselunterschied von Claude Code ist das Ökosystem rund um CLAUDE.md — Hooks, Custom-Commands, MCP-Server und Multi-Agent-Support verwandeln es von einer Konfigurationsdatei in ein vollständiges Automatisierungs-Framework.

---

Hooks: Ihren Claude-Code-Workflow automatisieren

Hooks werden in .claude/settings.json konfiguriert, nicht direkt in CLAUDE.md. Sie führen Shell-Befehle automatisch vor oder nach Claude-Code-Events aus.

Hook-Konfigurationsstruktur

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "echo 'File about to be modified'"
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "npx eslint --fix $CLAUDE_FILE_PATH"
      }
    ],
    "PreCommit": [
      {
        "command": "npm run lint && npm run test:changed"
      }
    ]
  }
}

Die nützlichsten Hook-Muster

Praktische Hook-Beispiele

Auto-Format nach jedem Datei-Edit:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "npx prettier --write $CLAUDE_FILE_PATH"
      }
    ]
  }
}

Tests für geänderte Dateien ausführen:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "command": "npx vitest run --reporter=verbose --changed"
      }
    ]
  }
}

---

Custom-Slash-Commands

Slash-Commands lassen Sie wiederverwendbare Prompt-Templates erstellen, die mit einem einzigen /-Befehl ausgelöst werden.

So erstellen Sie Slash-Commands

1. Erstellen Sie ein .claude/commands/-Verzeichnis in Ihrem Projekt
2. Fügen Sie Markdown-Dateien hinzu — jede Datei wird zu einem Command
3. Nutzen Sie $ARGUMENTS als Platzhalter für dynamischen Input

Beispiel: .claude/commands/review.md

Review the following code for:
1. Security vulnerabilities
2. Performance issues
3. Missing error handling
4. Test coverage gaps

Code to review: $ARGUMENTS

Provide a severity rating (low/medium/high/critical) for each finding.

Nutzung in Claude Code:

/project:review src/auth/login.ts

Nützliche Slash-Command-Ideen

---

MCP-Server: Claude Codes Fähigkeiten erweitern

MCP-Server (Model Context Protocol) verbinden Claude Code mit externen Tools und Diensten. Bei richtiger Konfiguration kann Claude Code Datenbanken abfragen, das Web browsen, Dateien verwalten, mit GitHub interagieren und vieles mehr — alles aus Ihrer Coding-Session heraus.

So konfigurieren Sie MCP-Server

MCP-Server werden in .claude/settings.json eingerichtet:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://localhost:5432/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
    }
  }
}

Die beliebtesten MCP-Server für Entwickler

MCP in CLAUDE.md referenzieren

Ihre CLAUDE.md kann Claude Code anweisen, wann und wie verbundene MCP-Server zu nutzen sind:

## Available Tools
- Use the postgres MCP to check schema before writing migrations
- Use the github MCP to create PRs after completing feature branches
- Use the memory MCP to track progress on multi-step tasks

---

Das virale 27-Agenten-Setup: Wie ein Google-Engineer 80 % seiner Arbeit automatisierte

Anfang 2026 ging ein Twitter-Thread eines Google-Engineers viral, der beschrieb, wie er 27 spezialisierte Claude-Code-Agenten einrichtete, um verschiedene Teile seines Workflows zu bewältigen. Jeder Agent hatte seine eigene CLAUDE.md mit engen, fokussierten Anweisungen.

Die Kern-Erkenntnis

Statt einer Allzweck-Claude-Code-Session, die alles versuchte, zerlegte er seine Arbeit in spezialisierte Rollen. Jeder Agent hatte:

• Eine eigene CLAUDE.md mit domänenspezifischem Wissen
• Eingeschränkten Tool-Zugriff (nur, was dieser Agent braucht)
• Klare Grenzen, was er anfassen sollte und was nicht
• Spezifische Output-Formate und Qualitätsstandards

Beispiel-Agent-Aufschlüsselung

So replizieren Sie dieses Setup

Sie brauchen keine 27 Agenten, um von diesem Muster zu profitieren. Starten Sie mit 3–5 spezialisierten Konfigurationen:

1. Separate CLAUDE.md-Dateien pro Rolle erstellen:

.claude/agents/frontend.md
.claude/agents/backend.md
.claude/agents/testing.md

2. Claude Code mit spezifischer Konfiguration starten:

# Use different profiles by combining global + agent-specific context
claude --profile frontend

3. Klare Übergabepunkte definieren:

Ihre primäre CLAUDE.md kann referenzieren, wann Agenten zu wechseln sind:

## Agent Workflow
- Frontend changes: use the frontend agent profile
- API changes: use the backend agent profile
- After any code change: run the test agent
- Before merging: run the review agent

Warum das funktioniert

Der 27-Agenten-Ansatz funktioniert wegen eines grundlegenden Prinzips der AI-Produktivität: enger Kontext produziert besseren Output als breiter Kontext. Eine Claude-Code-Session, geladen mit 400 Zeilen Anweisungen zu Frontend, Backend, DevOps, Testing und Dokumentation, performt bei jeder einzelnen Aufgabe schlechter als eine, die mit 50 hochrelevanten Zeilen geladen ist.

---

Häufige CLAUDE.md-Fehler (und wie man sie behebt)

Fehler 1: Zu vage sein

Schlecht:

Write good code that follows best practices.

Gut:

- Use TypeScript strict mode, no implicit any
- All functions must have JSDoc comments
- Error handling: wrap async operations in try/catch
- Max function length: 30 lines

Fehler 2: Mit Anweisungen überladen

500+ Zeilen Anweisungen führen dazu, dass Claude Code wichtige Regeln depriorisiert. Halten Sie Ihre CLAUDE.md fokussiert.

Fehler 3: CLAUDE.md nicht versionskontrollieren

Ihre CLAUDE.md sollte in Git committed sein. Das sichert:

• Team-Konsistenz
• Änderungshistorie und Verantwortlichkeit
• Einfaches Rollback, falls Anweisungen Probleme verursachen
• PR-Reviews für Anweisungsänderungen

Fehler 4: Den Security-Abschnitt ignorieren

Fügen Sie immer Security-Regeln in Ihre CLAUDE.md ein:

## Security (CRITICAL — never ignore)
- NEVER hardcode API keys, tokens, or passwords
- NEVER commit .env files
- ALWAYS use parameterized database queries
- ALWAYS validate and sanitize user input
- NEVER expose stack traces or internal errors to users

Fehler 5: Den Tech-Stack zu erwähnen vergessen

Claude Code kann Ihren Stack aus Code ableiten, aber explizite Deklarationen verhindern falsche Annahmen:

## Stack (authoritative — do not infer differently)
- Runtime: Node.js 22 (NOT Deno, NOT Bun)
- Framework: Next.js 15 App Router (NOT Pages Router)
- ORM: Prisma (NOT Drizzle, NOT TypeORM)
- Package manager: pnpm (NOT npm, NOT yarn)

---

Claude Code Best Practices: Power-User-Tipps

Tipp 1: Conditional Instructions nutzen

## Environment-Specific Rules
- In development: use verbose logging, skip minification
- In production: no console.log, enable all optimizations
- In CI: run full test suite, fail on any warning

Tipp 2: Output-Formate definieren

## When I ask for a code review, respond with:
1. **Summary** (1-2 sentences)
2. **Issues found** (bulleted, severity-tagged)
3. **Suggested fixes** (with code snippets)
4. **Overall grade** (A/B/C/D/F)

Tipp 3: Grenzen für Abhängigkeiten setzen

## Dependency Rules
- NEVER install packages with fewer than 1,000 weekly downloads
- NEVER install packages with known CVEs
- Prefer built-in Node.js APIs over third-party packages
- Always check bundle size impact before adding frontend deps

Tipp 4: Memory-Dateien für lange Projekte nutzen

## Memory
- Track all completed features in .claude/memory/features.md
- Log all architecture decisions in .claude/memory/decisions.md
- Update progress after each session

Tipp 5: Mit Ihrer CI/CD integrieren

Ihre CLAUDE.md kann Claude Code anweisen, Ihre CI-Pipeline zu respektieren:

## Before pushing any code:
1. Run `pnpm lint` — fix all errors
2. Run `pnpm test` — all tests must pass
3. Run `pnpm build` — build must succeed
4. Check bundle size — must not exceed 250KB

---

Wie viel kostet Claude Code? (Und wie bekommt man Credits)

Claude Code nutzt API-Credits, was bedeutet, dass Ihre Kosten davon abhängen, welches Modell Sie nutzen und wie viel Kontext Sie ihm geben.

Claude-Code-Kostenaufschlüsselung

Ein typischer intensiver Claude-Code-Tag nutzt 500K–2M Tokens und kostet je nach Modellwahl 2–30 $. Eine gut konfigurierte CLAUDE.md reduziert den Token-Verbrauch durch Eliminierung wiederholten Kontexts.

Kostenlose Credits für Claude Code sichern

Der beste Weg, Ihre Claude-Code-Nutzung zu finanzieren, ist über Credit-Programme:

Gesamt stapelbare Credits: bis zu 230.000 $+ über alle Programme.

Anthropic-Credits | AWS-Credits | Google-Cloud-Credits | Azure-Credits

Eine einzige CLAUDE.md-Datei in Kombination mit 5.000–25.000 $ an Startup-Credits gibt Ihnen 3–6 Monate intensive Claude-Code-Entwicklung zu null Kosten. Durchsuchen Sie alle verfügbaren Credit-Programme bei ClaimAICredits, um zu finden, wofür Sie qualifiziert sind.

---

Schnellreferenz: CLAUDE.md-Cheat-Sheet

---

Heute starten

Die CLAUDE.md-Datei ist die Konfiguration mit der höchsten Hebelwirkung, die Sie für AI-gestützte Entwicklung einrichten können. Starten Sie mit dem einfachen Template aus diesem Leitfaden, committen Sie es in Ihr Repo und iterieren Sie basierend darauf, was für Ihren Workflow funktioniert.

Die Engineers, die den meisten Wert aus Claude Code ziehen, schreiben keine besseren Prompts — sie schreiben bessere CLAUDE.md-Dateien. Das virale 27-Agenten-Setup beweist, dass durchdachte Konfiguration Brute-Force-Prompting jedes Mal schlägt.

Wenn Claude Codes API-Kosten Sie davon abhalten, mit fortgeschrittenen Setups wie Multi-Agent-Workflows zu experimentieren, erkunden Sie die kostenlosen Credit-Programme bei ClaimAICredits. Das Stapeln von Credits von Anthropic, AWS und Google Cloud kann Ihnen Monate kostenlose Entwicklungszeit geben, um Ihre CLAUDE.md-Konfiguration zu perfektionieren.