# Claude Code – Komplettes Tutorial

Dies ist ein umfassendes Claude Code Tutorial für Entwickler. Ob Sie neu in KI-Coding-Tools sind oder von anderen Tools migrieren — dieser Leitfaden hilft Ihnen, Claude Code zu beherrschen: den leistungsfähigsten KI-Coding-Assistenten 2026.

---

## 1. Was ist Claude Code

### Ein agentischer Coding-Assistent, keine Codevervollständigung

Claude Code ist Anthropics offizieller CLI-**agentischer Coding-Assistent**. Im Gegensatz zu traditionellen Codevervollständigungs-Tools wie GitHub Copilot verhält es sich wie ein erfahrener Entwickler:

- **Versteht die Aufgabe eigenständig**: Sie beschreiben, was Sie möchten, es erstellt einen Plan
- **Arbeitet direkt am Code**: liest, bearbeitet und erstellt jede Datei im Projekt
- **Führt Terminalbefehle aus**: Tests, Abhängigkeitsinstallationen, Builds
- **Versteht das Projekt tiefgehend**: 200K Token Kontextfenster standardmäßig (`claude-opus-5` / `claude-sonnet-5` und weitere erweitern auf 1M)
- **Dispatcht Subagenten**: teilt eine komplexe Aufgabe auf mehrere spezialisierte Subagenten auf, die parallel laufen

### Wer nutzt es

Seit der Veröffentlichung im Mai 2025 ist Claude Code ein zentrales Entwicklungswerkzeug bei führenden Unternehmen weltweit, darunter Netflix, Spotify, KPMG, L'Oréal und Salesforce. Es erreichte die Marke von $1B Jahresumsatz in nur sechs Monaten.

### Wichtige Updates 2025-2026

| Update | Funktion |
|------|------|
| **Plan Mode** | Erst recherchieren und analysieren, dann einen Plan vorschlagen — weniger Fehler |
| **Agent Teams** | Mehrere Agenten arbeiten parallel, isoliert via git worktree |
| **Voice Mode** | Sprachinteraktion — Taste halten und sprechen |
| **Computer Use** | Steuert Desktop, Browser und Entwicklerwerkzeuge |
| **Hooks system** | 17 Lifecycle-Ereignisse zur Automatisierung von Workflows |
| **MCP protocol** | Verbindet externe Tools und Dienste |
| **Skills** | Wissensmodule — teilbare Workflow-Vorlagen |
| **Extended Thinking** | Denkt vor der Antwort auf schwierige Fragen tiefgehend nach |
| **Opus 5 / Sonnet 5** | Aktuelles Flaggschiff und täglicher Standard (4.8 / 4.6 weiterhin im Angebot) |
| **1M Context Beta** | `claude-sonnet-5` / `claude-opus-5` und weitere unterstützen ein 1M-Token-Kontextfenster |

### Warum über QCode.cc

Claude Code direkt vom chinesischen Festland aus zu nutzen, führt zu zwei Problemen: das Netzwerk ist nicht erreichbar und die Kosten sind hoch. Über QCode.cc:

- **Geringe Latenz auf Asien-Pazifik-Knoten** — kein VPN oder selbst gehosteter Proxy nötig
- **Bis zu 80% geringere Kosten** gegenüber offiziellen Preisen
- **Claude Code und Codex teilen ein Plan-Kontingent** — ein Plan, zwei Tools
- **Hohe Verfügbarkeit über Knoten hinweg** (Asien / Nordamerika & Europa / global Route 53)

---

## 2. Installation & Einrichtung

### Systemanforderungen

| Anforderung | Detail |
|------|------|
| OS | macOS 12+, Ubuntu 20.04+, Windows 10+ (WSL2) |
| Node.js | 18.0 oder neuer (22 LTS empfohlen) |
| Git | 2.x oder neuer |
| Speicherplatz | ca. 200MB |

### Claude Code installieren

```bash
# npm install (recommended)
npm install -g @anthropic-ai/claude-code

# Users in China can speed this up with the Taobao mirror
npm install -g @anthropic-ai/claude-code --registry=https://registry.npmmirror.com
```

### QCode.cc konfigurieren

Setzen Sie die Umgebungsvariablen in Ihrem Terminal:

```bash
# Add to ~/.bashrc or ~/.zshrc
export ANTHROPIC_BASE_URL=https://api.qcode.cc/api
export ANTHROPIC_AUTH_TOKEN=cr_your_api_key
```

> **Warum `ANTHROPIC_AUTH_TOKEN` und nicht `ANTHROPIC_API_KEY`**: Ein QCode.cc-Schlüssel, der mit `cr_` beginnt, ist ein **Drittanbieter-Gateway-Schlüssel**, kein offizieller Anthropic-Schlüssel. Wenn Claude Code `ANTHROPIC_AUTH_TOKEN` sieht, sendet es `Authorization: Bearer <token>` an das Gateway; mit `ANTHROPIC_API_KEY` sendet es stattdessen `x-api-key`, was mit der OAuth-Sitzung eines Anthropic-Kontos kollidieren kann, bei dem Sie bereits angemeldet sind. **Die Verwendung von `ANTHROPIC_AUTH_TOKEN` ist die offizielle QCode-Empfehlung.**

> **Holen Sie sich Ihren API-Key** in der [QCode.cc Konsole](https://qcode.cc/dashboard); er beginnt mit `cr_`.

> **Endpunktauswahl**: Der Standard ist `https://api.qcode.cc/api` (global Route 53 wählt automatisch den nächstgelegenen Knoten). Nutzer vom chinesischen Festland sollten `asia.qcode.cc` bevorzugen (Asien-Knoten, nächstgelegener von Korea / Taiwan / Hong Kong, geringste Latenz). Die anderen Domains (`us` / `asia`) und die BASE_URL-Regeln sind in [Endpunkte & API-Formate](/docs/getting-started/endpoints-and-api-paths) beschrieben.

Wenden Sie die Konfiguration an:

```bash
source ~/.bashrc  # or source ~/.zshrc
```

### Installation überprüfen

```bash
# Check the version
claude --version
# Prints a version number (yours may differ, see https://github.com/anthropics/claude-code/releases)

# Quick test
claude -p "Hello, please introduce yourself"
```

Wenn Claude antwortet, waren Installation und Konfiguration erfolgreich.

### Shell-Vervollständigung (optional)

```bash
# Bash
claude completion bash >> ~/.bashrc

# Zsh
claude completion zsh >> ~/.zshrc

# Fish
claude completion fish > ~/.config/fish/completions/claude.fish
```

---

## 3. Erste Verwendung

### Start

Führen Sie es in einem beliebigen Projektverzeichnis aus:

```bash
cd ~/my-project
claude
```

Claude Code durchsucht die Projektstruktur automatisch und wechselt in den interaktiven Modus.

### Die Oberfläche lesen

```text
╭─────────────────────────────────────────╮
│ claude                                   │
│                                          │
│ Project: my-project                      │
│ Model: claude-sonnet-5                   │
│ Context: 12,345 / 1,000,000 tokens       │
╰─────────────────────────────────────────╯

> _
```

Geben Sie Aufgaben in natürlicher Sprache ein – Claude versteht sie und handelt entsprechend.

### Erste Aufgabe: das Projekt verstehen

```text
> Analyse this project's architecture and tell me the main modules and how they relate
```

Claude führt automatisch folgende Schritte aus:
1. Liest `package.json`, `README.md` und die Verzeichnisstruktur
2. Überfliegt die wichtigsten Quelldateien
3. Erstellt eine strukturierte Architekturanalyse

### Berechtigungsanfragen

Wenn Claude eine Aktion ausführen möchte, bittet es Sie um Bestätigung:

```text
Claude wants to run:
  Tool: Bash
  Command: npm test

  [y] allow  [n] deny  [a] always allow in this session
```

- **y**: einmalig erlauben
- **n**: ablehnen
- **a**: diese Art von Aktion für den Rest der Sitzung immer erlauben (praktisch für die tägliche Entwicklung)

### Gängige Berechtigungsmodi

| Modus | Funktion | Einsatzgebiet |
|------|------|---------|
| Standard | Jede Aktion bestätigen | Erste Verwendung, sensible Projekte |
| `--allowedTools` | Festlegen, welche Tools erlaubt sind | Eingegrenzte Automatisierung |
| `--dangerously-skip-permissions` | Alle Bestätigungen überspringen | Isolierte Docker-Umgebungen, CI/CD |

---

## 4. Kernfunktionen

### 4.1 Plan-Modus

Der Plan-Modus veranlasst Claude, zunächst zu recherchieren und zu analysieren, bevor ein Plan vorgeschlagen wird. Er eignet sich für komplexe Aufgaben.

```bash
# Enter plan mode
> /plan

# Or trigger it from the prompt
> Analyse the requirements and draft a plan first — don't change any code yet
```

**Funktionsweise**:
1. Claude analysiert die Codebasis und die Anforderungen
2. Es schlägt einen Plan vor (welche Dateien erstellt/geändert werden, in welcher Reihenfolge)
3. Sie prüfen den Plan und bitten um Änderungen
4. Nach der Bestätigung führt Claude den Plan aus

**Beispiel**:

```text
> /plan
> I want to add JWT-based user authentication to this project

Claude: Let me analyse the current project structure and draft a plan...

📋 Plan:
1. Create src/middleware/auth.ts — JWT verification middleware
2. Create src/services/auth-service.ts — authentication business logic
3. Modify src/routes/index.ts — add login/register routes
4. Create src/models/user.ts — user data model
5. Add dependencies: jsonwebtoken, bcrypt
6. Create test files

Does this plan work? Anything to adjust?
```

### 4.2 Erweitertes Denken

Opus 5 (sowie 4.8 / 4.7, weiterhin im Angebot) verfügt über ein eingebautes erweitertes Denken – wir empfehlen adaptives Denken in Kombination mit dem effort-Parameter, siehe den [Leitfaden zur Konfiguration des adaptiven Denkens](/docs/usage/adaptive-thinking). Bei schwierigen Problemen denkt Claude zunächst intern gründlich nach.

```text
> I've been chasing this concurrency bug for two days. Analyse the race condition in src/worker.ts

[Claude reasons internally for thousands of tokens, walking execution paths, locking and timing]

Claude: Found it. On line 127 of worker.ts...
```

**Wann es automatisch aktiv wird**:
- Komplexes Debugging
- Analyse auf Architekturebene
- Mehrstufige Reasoning-Ketten

### 4.3 Sub-Agents

Claude kann spezialisierte Sub-Agents für bestimmte Aufgaben starten:

```text
> Review this PR for me, and check for security issues at the same time

Claude: I'll start two subagents in parallel:
  - Subagent 1: code quality review
  - Subagent 2: security vulnerability scan
```

Sub-Agents laufen in einem eigenen Kontext, sodass sie die Hauptsitzung nicht belasten.

### 4.4 Wichtige Befehle

| Befehl | Funktion | Beispiel |
|------|------|------|
| `/model` | Modell wechseln | `/model opus` |
| `/plan` | Plan-Modus aktivieren | `/plan` |
| `/compact` | Kontext komprimieren | `/compact` |
| `/cost` | Aktuelle Kosten anzeigen | `/cost` |
| `/clear` | Kontext löschen | `/clear` |
| `/init` | CLAUDE.md generieren | `/init` |
| `/review` | Code-Review | `/review` |
| `/help` | Hilfe | `/help` |
| `Esc` | Aktuelle Aktion abbrechen | |
| `Ctrl+C` | Antwort unterbrechen | |

### 4.5 Kontextverwaltung

Claude Code verfügt über ein Kontextfenster von 200K Tokens. Lange Sitzungen müssen verwaltet werden:

```bash
# Check current context usage
/cost

# Compact the context (keep what matters, free space)
/compact

# Start a completely new session
/clear
```

**Bewährte Praktiken**:
- Führen Sie `/compact` aus, sobald die Kontextnutzung 70 % überschreitet
- Starten Sie bei einem Aufgabenwechsel eine neue Sitzung mit `/clear`
- Halten Sie Hintergrundinformationen bei komplexen Projekten in CLAUDE.md (`/compact` entfernt sie niemals)

---
## 5. CLAUDE.md — Projektkonfiguration

### Warum Sie CLAUDE.md benötigen

Jedes Mal, wenn Claude Code startet, liest es die `CLAUDE.md` des Projekts, um die Architektur, Codestandards und lokalen Konventionen zu erfassen. Ohne diese Datei müssen Sie das Projekt in jeder Sitzung erneut erklären.

### Schnell anlegen

```bash
# Claude analyses the project and generates the file
/init
```

### Datei-Hierarchie

| Speicherort | Geltungsbereich | Git |
|------|---------|---------|
| `~/.claude/CLAUDE.md` | Global (alle Projekte) | Nicht versioniert |
| `project root/CLAUDE.md` | Dieses Projekt | In Git einchecken |
| `.claude/CLAUDE.md` | Dieses Projekt (privat) | Zu .gitignore hinzufügen |
| `subdirectory/CLAUDE.md` | Nur dieses Unterverzeichnis | Bei Bedarf |

### Praxisvorlage: React + TypeScript-Projekt

```markdown
# MyApp

## Tech Stack
- React 19 + TypeScript 5.x + Vite
- Styling: Tailwind CSS v4
- State: Zustand
- Testing: Vitest + Testing Library

## Commands
- Dev: `pnpm dev`
- Test: `pnpm test`
- Build: `pnpm build`
- Lint: `pnpm lint`

## Coding Standards
- Function components only; define Props with an interface
- The any type is not allowed
- CSS through Tailwind utility classes only
- Commit format: feat: / fix: / docs:

## Project Structure
- src/components/ — reusable components
- src/pages/ — page components
- src/hooks/ — custom hooks
- src/lib/ — utility functions
- src/api/ — API request wrappers

## Notes
- Node.js 22+, pnpm as the package manager
- All API requests go through src/api/client.ts
```

> Die vollständige Anleitung finden Sie unter [CLAUDE.md-Konfiguration](/docs/usage/claude-md).

---

## 6. Modellauswahl

### Die drei Modelle im Vergleich

Die Preise sind eine Momentaufnahme vom 2026-08-16 von [qcode.cc/models](https://qcode.cc/models); **diese Seite ist die maßgebliche Quelle**. Die Modelle der 4.x-Serie sind weiterhin im Angebot, sie sind lediglich nicht mehr standardmäßig ausgewählt.

| | Opus 5 | Sonnet 5 | Haiku 4.5 |
|--------|----------|------------|-----------|
| **Position** | Aktuelles Flaggschiff | Täglicher Standard | Leicht und schnell |
| **Reasoning** | Sehr stark | Stark | Ausreichend |
| **Code-Qualität** | Sehr hoch | Hoch | Mittel |
| **Antwortgeschwindigkeit** | Langsamer | Mittel | Schnell |
| **Kontext** | 1M / 128K | 1M / 128K | 200K |
| **Input-Preis** | $5.00/M | $2.00/M | $1.00/M |
| **Output-Preis** | $25.00/M | $10.00/M | $5.00/M |

### Modelle wechseln

```bash
# Switch inside an interactive session
/model opus    # switch to Opus
/model sonnet  # switch to Sonnet
/model haiku   # switch to Haiku

# Specify at launch
claude --model claude-opus-5
```

### Empfehlungen nach Szenario

| Szenario | Empfehlung | Warum |
|------|---------|------|
| Architekturdesign | **Opus** | Tiefgründiges Reasoning, behält das Gesamtbild im Blick |
| Tägliche Entwicklung | **Sonnet** | Bestes Preis-Leistungs-Verhältnis |
| Fehlerbehebung | **Sonnet** | Ausreichend gut und schnell |
| Schwieriges Debugging | **Opus** | Extended Thinking |
| Code-Formatierung | **Haiku** | Das günstigste Modell für einfache Aufgaben verwenden |
| PR-Review | **Sonnet** | Gute Balance zwischen Geschwindigkeit und Qualität |
| Große Refactorings | **Opus** | Erfordert Verständnis des gesamten Projekts |
| Dokumentation erstellen | **Sonnet** | Ausreichend gut |

### Eine gemischte Strategie (empfohlen)

```text
A day's model usage:
├── Sonnet 5 (70%) — everyday development, bug fixes, tests
├── Opus 5  (15%) — architecture decisions, hard problems
└── Haiku 4.5 (15%) — formatting, simple questions, bulk operations
```

Sie können jederzeit während einer Konversation wechseln:

```bash
# Plan with Opus first
/model opus
> Analyse this module's architecture and draft a refactoring plan

# Once the plan is agreed, switch to Sonnet to execute
/model sonnet
> Carry out step one of the plan
```

---

## 7. Erweiterte Tipps

### Hooks

Konfigurieren Sie Automatisierungs-Hooks in `.claude/settings.json`:

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $FILEPATH"
          }
        ]
      }
    ]
  }
}
```

> Vollständige Anleitung: [Hooks-System](/docs/advanced/hooks).

### MCP-Server

Verbinden Sie externe Tools über das Model Context Protocol:

```json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_xxx" }
    }
  }
}
```

### Skills

Skills sind wiederverwendbare Wissensmodule:

```bash
# List available skills
/skills

# Use a specific skill
> /commit    # generate a commit with the commit skill
> /review    # review code with the review skill
```

### --bare-Modus

Skriptbasierter Aufruf ohne interaktive Funktionen:

```bash
claude --bare -p "List every TODO comment" --output-format json
```

---
## 8. Praktische Beispiele

### Beispiel 1: Ein unbekanntes Projekt erschließen

```bash
cd ~/unfamiliar-project
claude
```

```text
> Analyse this project:
> 1. which technologies it uses
> 2. the core modules and their responsibilities
> 3. how data flows through it
> 4. draw a simple architecture diagram (ASCII)
```

Claude durchsucht package.json, die Quellcode-Verzeichnisse und die Konfigurationsdateien und erstellt eine vollständige Übersicht des Projekts.

### Beispiel 2: Eine Funktion mit Plan Mode implementieren

```text
> /plan
> I need to add rate limiting to the API:
> - at most 60 requests per minute per user
> - store counters in Redis
> - return 429 with a Retry-After header when exceeded

Claude:
📋 Plan:
1. Install dependency: ioredis
2. Create src/middleware/rate-limiter.ts
3. Create src/config/rate-limit.ts (settings)
4. Modify src/app.ts (register the middleware)
5. Create tests/rate-limiter.test.ts
6. Update docker-compose.yml (add the Redis service)

Confirm and I'll start.

> The plan looks good, go ahead
```

### Beispiel 3: Einen schwierigen Bug debuggen

```text
/model opus
> Users report that "stock occasionally goes negative when orders are placed concurrently".
> Analyse src/services/order-service.ts and src/services/inventory-service.ts,
> find the concurrency bug and fix it.

[Opus engages Extended Thinking and walks execution paths, locking and transaction isolation levels]

Claude: Found it. On line 45 of inventory-service.ts the stock check and the decrement are not in the same transaction,
which is a TOCTOU race. The fix is to use SELECT FOR UPDATE...
```

### Beispiel 4: Batch-Refactoring

```text
> All class components in the project need to become function components + Hooks.
> Work through every .tsx file under src/components/ one at a time.

Claude will:
1. Find every class component
2. Convert them one by one to function components
3. Turn lifecycle methods into useEffect
4. Turn this.state into useState
5. Run the tests to confirm nothing broke
```

### Beispiel 5: Eine vollständige Testsuite schreiben

```text
> Write a complete unit test suite for src/services/user-service.ts:
> - cover every public method
> - include both happy and error paths
> - mock external dependencies (database, cache)
> - target 90%+ coverage
```

### Beispiel 6: CI/CD-Automatisierung

```bash
# Inside GitHub Actions
claude -p "Review the code changes in this PR, focusing on security and performance" \
  --output-format json \
  --max-turns 3 \
  --allowedTools Read,Glob,Grep
```

> Weitere CI/CD-Beispiele: [Automatisierung & CI/CD](/docs/advanced/headless).

---

## 9. Claude Code + Codex zusammen

Claude Code und OpenAI Codex CLI sind die beiden stärksten AI-Coding-Tools des Jahres 2026, jeweils mit eigenen Stärken.

**Die ideale Kombination**: Claude Code plant und prüft, Codex führt aus und erledigt die Massenarbeit.

```bash
# 1. Claude Code drafts the plan
claude
> /plan
> Design an implementation plan for the user permission system

# 2. Codex executes it
codex "Follow the plan in PLAN.md and implement steps 1-3"
```

> **Ein QCode.cc-Tarif, ein gemeinsames Kontingent für beide Tools** – das Wechseln kostet nichts.
> Vollständiger Vergleich: [Codex vs. Claude Code](/docs/getting-started/codex-vs-claude-code).
> Codex-Anleitung: [Komplettes Codex-Tutorial](/docs/ide/codex).

---

> **Arbeiten Sie im Team?** Für Teams ab drei Personen empfehlen wir den [Enterprise-Team-Plan](https://qcode.cc/enterprise) – eine dedizierte Domain `e-xxx.qcode.cc`, Verwaltung von Sub-API-Keys, Kontoschutz, Unternehmensübertragung und Rechnungen. Siehe [Enterprise-Leitfaden](/docs/reference/enterprise-guide).

## 10. FAQ

### Installation schlägt fehl

**Q: `npm install -g` liefert einen Berechtigungsfehler**

```bash
# Option 1: use sudo
sudo npm install -g @anthropic-ai/claude-code

# Option 2: manage Node.js with nvm (recommended)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
nvm install 22
npm install -g @anthropic-ai/claude-code
```

### Netzwerkprobleme

**Q: Die Verbindung läuft in ein Timeout oder wird abgelehnt**

```bash
# Check the configuration
echo $ANTHROPIC_BASE_URL    # should be https://api.qcode.cc/api
echo $ANTHROPIC_AUTH_TOKEN  # should start with cr_

# Test connectivity
curl -s -o /dev/null -w '%{http_code}\n' \
  -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" https://api.qcode.cc/api/v1/models
# -> 200 + a JSON model list = address, key and network all fine
```

### Kostenkontrolle

**Q: Ich mache mir Sorgen um die Rechnung**

- Nutzen Sie **Sonnet** im Alltag (60 % günstiger als Opus)
- Prüfen Sie die Ausgaben jederzeit mit `/cost`
- Verwenden Sie `/compact`, um den Kontext zu verkleinern und den Token-Verbrauch zu senken
- Leiten Sie einfache Aufgaben an **Haiku** (das günstigste Modell) weiter
- Siehe den [Leitfaden zur Kostenoptimierung](/docs/usage/cost-optimization)

### Claude versteht das Projekt nicht

**Q: Claude interpretiert die Projektstruktur oder Konventionen immer wieder falsch**

Erstellen Sie eine `CLAUDE.md` (siehe Kapitel 5) und notieren Sie dort den Projekthintergrund, Konventionen und häufig verwendete Befehle. Claude liest diese Datei automatisch bei jedem Start.

### Abgrenzung zu anderen Tools

**Q: Worin unterscheidet sich Claude Code von Cursor / Copilot?**

| Tool | Typ | Charakter |
|------|------|------|
| **Claude Code** | CLI-Agent | Plant und führt autonom aus, versteht das gesamte Projekt |
| **Cursor** | IDE | Tiefe Editor-Integration, Echtzeit-Vervollständigung |
| **Copilot** | IDE-Plugin | Zeilenvervollständigung, einfache Vorschläge |

Claude Code ist ein Assistent auf Agentenebene (es kann komplexe Aufgaben eigenständig abschließen), kein Werkzeug für Zeilenvervollständigung. Beide ergänzen sich gut: Cursor für Echtzeit-Bearbeitung und Vervollständigung, Claude Code für die Planung und Ausführung komplexer Aufgaben.

> **Hinweis**: Derselbe QCode.cc-`cr_`-Key funktioniert mit Claude Code, Codex CLI und einer Vielzahl von IDEs / CLIs / Desktop-Apps, einschließlich Cursor. Für Cursor (benutzerdefinierte Base URL + API-Key) siehe [Cursor-Editor-Integration](/docs/ide/cursor); die Protokollmatrix und die vollständige Liste finden Sie unter [Übersicht der Tool-Kompatibilität](/docs/ide/tool-compatibility).

---
## Weiterführende Dokumentation

- [Installationsleitfaden](/docs/getting-started/installation) — detaillierte Installationsschritte
- [CLAUDE.md-Konfiguration](/docs/usage/claude-md) — der vollständige Leitfaden zur Projektkonfiguration
- [Hook-System](/docs/advanced/hooks) — Automatisierungs-Hooks im Detail
- [Automatisierung & CI/CD](/docs/advanced/headless) — Nutzung des Headless-Modus
- [Modellauswahl-Leitfaden](/docs/usage/model-selection) — detaillierter Modellvergleich
- [Kostenoptimierung](/docs/usage/cost-optimization) — Techniken zur Kostenkontrolle
- [Codex vs. Claude Code](/docs/getting-started/codex-vs-claude-code) — Vergleich der beiden Tools
- [Vollständiges Codex-Tutorial](/docs/ide/codex) — der vollständige Codex-Leitfaden
- [Tarife & Preise](https://qcode.cc/pricing) — QCode.cc-Tarife