Claude Code CLI: Kompletny przewodnik

TL;DR: Claude Code to agentowy CLI, który odczytuje bazę kodu, wykonuje polecenia i modyfikuje pliki poprzez warstwowy system uprawnień, hooks, integracji MCP oraz subagents. Opanowanie pięciu kluczowych systemów (konfiguracja, uprawnienia, hooks, MCP i subagents) pozwala osiągnąć zwielokrotnioną produktywność. Należy dobrać warstwę modelu odpowiednią do zadania — Opus do złożonego rozumowania, Sonnet do pracy ogólnej, Haiku do szybkiej eksploracji — lub ustandaryzować na Opus, jeśli jakość jest jedyną zmienną. Hooks (nie prompty) należy stosować do wszystkiego, co musi być wykonywane za każdym razem.

Claude Code działa jako system agentowy, a nie interfejs czatu z wiedzą programistyczną. CLI odczytuje bazę kodu, wykonuje polecenia, modyfikuje pliki, zarządza przepływami pracy git, łączy się z zewnętrznymi usługami przez MCP i deleguje złożone zadania do wyspecjalizowanych subagents. Wszystko przepływa przez interfejs wiersza poleceń, który integruje się ze sposobem, w jaki programiści faktycznie pracują. Od lutego 2026 roku 4% publicznych commitów na GitHub (~135 000 dziennie) jest tworzonych przez Claude Code — wzrost 42 896× w ciągu 13 miesięcy od wersji preview — a 90% kodu Anthropic jest napisane przez AI.¹¹⁰

Różnica między przypadkowym a efektywnym użyciem Claude Code sprowadza się do pięciu kluczowych systemów. Opanowanie ich sprawia, że Claude Code staje się mnożnikiem siły:

1. Hierarchia konfiguracji: kontroluje zachowanie
2. System uprawnień: zarządza dostępem do operacji
3. System hooks: umożliwia deterministyczną automatyzację
4. Protokół MCP: rozszerza możliwości
5. System subagents: obsługuje złożone zadania wieloetapowe

Kluczowe wnioski

• Pięć systemów determinuje efektywność: hierarchia konfiguracji, uprawnienia, hooks, MCP i subagents kontrolują wszystko — od zachowania po automatyzację.
• Delegowanie pracy do warstwy delegacji: subagents zapobiegają rozrostowi kontekstu, izolując eksplorację w czystych oknach kontekstu i zwracając jedynie podsumowania.
• Hooks gwarantują wykonanie; prompty nie: hooks należy stosować do lintingu, formatowania i kontroli bezpieczeństwa, które muszą być uruchamiane za każdym razem, niezależnie od zachowania modelu.
• Warstwowe dobieranie modeli oszczędza koszty bez utraty jakości: eksplorację subagents można kierować do tańszych modeli, rezerwując Opus do faktycznego rozumowania architekturalnego — lub ustandaryzować na Opus, jeśli jakość jest jedyną zmienną.
• MCP łączy Claude z narzędziami w ekosystemie: bazy danych, GitHub, Sentry i ponad 3000 integracji rozszerzają możliwości Claude poza odczyt plików i polecenia bash.

Spędziłem miesiące, testując Claude Code do granic możliwości w produkcyjnych bazach kodu, pipeline’ach CI/CD i wdrożeniach enterprise. Ten przewodnik destyluje to doświadczenie w kompletne źródło wiedzy, które chciałbym mieć, gdy zaczynałem. Każda funkcja zawiera faktyczną składnię, realne przykłady konfiguracji oraz przypadki brzegowe, które potrafią zaskoczyć doświadczonych użytkowników.

Jak korzystać z tego przewodnika

To ponad 5000 linii materiału referencyjnego — nie trzeba czytać go od deski do deski. Zacznij od poziomu odpowiadającego Twojemu doświadczeniu:

Można użyć Ctrl+F / Cmd+F w przeglądarce, aby wyszukać konkretne flagi, polecenia lub klucze konfiguracji. Karta szybkiego odniesienia na końcu zawiera czytelne podsumowanie wszystkich głównych poleceń.

Jak działa Claude Code: model mentalny

Zanim przejdziemy do szczegółów funkcji, warto zrozumieć, jak architektura Claude Code wpływa na wszystko, co się z nim robi. System działa w trzech warstwach:

┌─────────────────────────────────────────────────────────┐
│                    CLAUDE CODE LAYERS                    │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │   MCP   │  │  Hooks  │  │ Skills  │  │ Plugins │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
│  External tools, deterministic automation, domain       │
│  expertise, packaged extensions                          │
├─────────────────────────────────────────────────────────┤
│  DELEGATION LAYER                                        │
│  ┌─────────────────────────────────────────────────┐    │
│  │              Subagents (up to 10 parallel)       │    │
│  │   Explore | Plan | General-purpose | Custom      │    │
│  └─────────────────────────────────────────────────┘    │
│  Isolated contexts for focused work, returns summaries  │
├─────────────────────────────────────────────────────────┤
│  CORE LAYER                                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │         Main Conversation Context                │    │
│  │   Tools: Read, Edit, Bash, Glob, Grep, etc.     │    │
│  └─────────────────────────────────────────────────┘    │
│  Your primary interaction; limited context; costs money │
└─────────────────────────────────────────────────────────┘

Warstwa podstawowa (Core Layer): Główna konwersacja. Każda wiadomość, odczyt pliku i wynik narzędzia zużywa kontekst ze wspólnego okna (standardowo 200K tokenów⁹⁸, 1M tokenów z Opus 4.6 lub modelami z rozszerzonym kontekstem). Gdy kontekst się zapełni, Claude traci orientację we wcześniejszych decyzjach, a jakość spada. Ta warstwa kosztuje za każdy token.

Warstwa delegowania (Delegation Layer): Subagenty uruchamiają się z czystym kontekstem, wykonują ukierunkowaną pracę i zwracają podsumowania. Wyniki eksploracji nie obciążają głównej konwersacji — wracają tylko wnioski. Można kierować subagenty do tańszych modeli na potrzeby eksploracji lub używać modelu głównego wszędzie, jeśli jakość jest ważniejsza niż koszt.

Warstwa rozszerzeń (Extension Layer): MCP łączy z zewnętrznymi usługami (bazy danych, GitHub, Sentry). Hooks gwarantują wykonanie poleceń powłoki niezależnie od zachowania modelu. Skills kodują wiedzę domenową, którą Claude stosuje automatycznie. Plugins pakują to wszystko do dystrybucji.

Kluczowy wniosek: Większość użytkowników pracuje wyłącznie w warstwie podstawowej, obserwując rosnący kontekst i koszty. Zaawansowani użytkownicy przenoszą eksplorację i wyspecjalizowane zadania do warstwy delegowania, utrzymują warstwę rozszerzeń skonfigurowaną pod swój przepływ pracy, a warstwę podstawową wykorzystują jedynie do orkiestracji i podejmowania ostatecznych decyzji.

Spis treści

1. Jak zainstalować Claude Code?
2. Szybki start: pierwsza sesja
3. Podstawowe tryby interakcji
4. System konfiguracji — szczegółowe omówienie
5. Który model wybrać?
6. Ile kosztuje Claude Code?
7. Ramy decyzyjne
8. Jak działa system uprawnień?
9. Jak działają hooks?
10. Czym jest MCP (Model Context Protocol)?
11. Czym są subagenty?
12. Czym jest tryb rozszerzonego myślenia?
13. Style wyświetlania
14. Polecenia ukośnikowe
15. Jak działają skills?
16. System plugins
17. Jak działa pamięć?
18. Obrazy i dane multimodalne
19. Tryb głosowy
20. Jak działa integracja z Git?
21. Jak używać Claude Code w IDE?
22. Zaawansowane wzorce użycia
23. Zdalne agenty i agenty w tle [RESEARCH PREVIEW]
24. Claude w Chrome
25. Claude Code w Slack [RESEARCH PREVIEW]
26. Claude Code w przeglądarce [RESEARCH PREVIEW]
27. Optymalizacja wydajności
28. Jak diagnozować problemy?
29. Wdrożenie w przedsiębiorstwie
30. Skróty klawiszowe — ściągawka
31. Najlepsze praktyki
32. Przepisy na przepływy pracy
33. Przewodnik migracji
34. Wskazówki dla konkretnych grup odbiorców
35. Karta szybkiego odniesienia
36. Historia zmian
37. Źródła

Jak zainstalować Claude Code?

Wymagania systemowe

Claude Code działa na macOS 10.15+, Ubuntu 20.04+/Debian 10+, oraz Windows 10+ poprzez WSL lub Git Bash. System wymaga minimum 4 GB RAM oraz aktywnego połączenia z internetem.⁹⁹ Najlepsza kompatybilność powłoki zapewniona jest z Bash, Zsh lub Fish.

W przypadku Windows działają zarówno WSL 1, jak i WSL 2. Git Bash również działa, jeśli preferowane jest natywne środowisko Windows. Alpine Linux i inne systemy oparte na musl wymagają dodatkowych pakietów:

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Metody instalacji

Instalacja natywna (zalecana)

Natywny plik binarny zapewnia najczystsze doświadczenie bez zależności od Node.js:

# macOS and Linux
curl -fsSL https://claude.ai/install.sh | bash

# Homebrew alternative
brew install --cask claude-code

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# Windows CMD
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Instalacja konkretnej wersji:

# Install specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58

# Install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest

# Windows PowerShell - specific version
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58

Instalacja przez NPM (przestarzała)

Uwaga: Od wersji v2.1.15 instalacje npm wyświetlają powiadomienie o wycofaniu. Natywny plik binarny jest teraz zalecaną metodą instalacji. Migracja możliwa za pomocą claude install.

Dla starszych środowisk, w których npm jest nadal potrzebny:

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

Nie należy używać sudo przy instalacji npm. Powoduje to problemy z uprawnieniami, które komplikują wszystkie dalsze operacje.

Migracja z istniejącej instalacji

W przypadku starszej instalacji opartej na npm można przeprowadzić migrację do natywnego pliku binarnego:

claude install

Opcje uwierzytelniania

Claude Code obsługuje trzy ścieżki uwierzytelniania, każda z innymi kompromisami:

Claude Console (rozliczanie API)

Połączenie z API Anthropic bezpośrednio przez platform.claude.com (wcześniej console.anthropic.com). Należy utworzyć konto, skonfigurować rozliczenia i uwierzytelnić się przez CLI. Console zapewnia rozliczanie według zużycia z pełnym dostępem do API. Dedykowany workspace „Claude Code” jest tworzony automatycznie; nie można tworzyć kluczy API dla tego workspace’u, ale można monitorować zużycie.

Subskrypcja Claude Pro lub Max

Wykorzystanie danych logowania konta claude.ai. Subskrypcja obejmuje zarówno interfejs webowy, jak i korzystanie z CLI w ramach jednego planu miesięcznego. Subskrypcja upraszcza rozliczenia dla indywidualnych użytkowników, którzy chcą przewidywalnych kosztów.

Platformy korporacyjne

AWS Bedrock, Google Vertex AI i Microsoft Foundry zapewniają dostęp klasy korporacyjnej z istniejącymi relacjami rozliczeniowymi w chmurze:

# AWS Bedrock
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1
export AWS_PROFILE=your-profile

# Google Vertex AI
export CLAUDE_CODE_USE_VERTEX=1
export CLOUD_ML_REGION=us-east5
export ANTHROPIC_VERTEX_PROJECT_ID=your-project

# Microsoft Foundry
export CLAUDE_CODE_USE_FOUNDRY=1
export ANTHROPIC_FOUNDRY_RESOURCE=your-resource-name
# Optional: API key auth (otherwise uses Entra ID)
export ANTHROPIC_FOUNDRY_API_KEY=your-key

Dla wdrożeń korporacyjnych za serwerami proxy lub przez bramki LLM:

# Corporate proxy
export HTTPS_PROXY='https://proxy.example.com:8080'

# LLM gateway (skip native auth)
export CLAUDE_CODE_USE_BEDROCK=1
export ANTHROPIC_BEDROCK_BASE_URL='https://your-gateway.com/bedrock'
export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1

Weryfikacja

claude doctor

Polecenie raportuje typ instalacji, wersję, konfigurację systemu oraz wszelkie wykryte problemy.

Zarządzanie uwierzytelnianiem (v2.1.41+)

Zarządzanie uwierzytelnianiem bez wchodzenia do REPL:⁹⁷

claude auth login          # Log in or switch accounts
claude auth status         # Check current auth state (account, plan, expiry)
claude auth logout         # Clear stored credentials

Typowy przepływ pracy przy przełączaniu między kontami lub organizacjami:

claude auth logout && claude auth login

Zobacz także: Jak debugować problemy? — rozwiązywanie problemów z uwierzytelnianiem.

Aktualizacje

Claude Code domyślnie aktualizuje się automatycznie, sprawdzając przy uruchomieniu i okresowo w trakcie sesji. Aktualizacje pobierają się w tle i są stosowane przy następnym uruchomieniu.

Wyłączenie automatycznych aktualizacji:

export DISABLE_AUTOUPDATER=1

Lub w settings.json:

{
  "env": {
    "DISABLE_AUTOUPDATER": "1"
  }
}

Ręczna aktualizacja:

claude update

Odinstalowanie

Instalacja natywna (macOS/Linux/WSL):

rm -f ~/.local/bin/claude
rm -rf ~/.claude-code

Instalacja natywna (Windows PowerShell):

Remove-Item -Path "$env:LOCALAPPDATA\Programs\claude-code" -Recurse -Force
Remove-Item -Path "$env:LOCALAPPDATA\Microsoft\WindowsApps\claude.exe" -Force

Czyszczenie konfiguracji (usuwa wszystkie ustawienia):

rm -rf ~/.claude
rm ~/.claude.json
rm -rf .claude
rm -f .mcp.json

Szybki start: pierwsza sesja

1. Instalacja i uruchomienie:

claude                           # Launch in current directory

2. Przejście do projektu:

cd ~/my-project && claude        # Or launch from any git repo

3. Poproszenie Claude o wykonanie zadania:

> "Explain the architecture of this project"
> "Find all TODO comments and create a summary"
> "Add input validation to the signup form"

4. Skróty klawiszowe podczas sesji:

/cost                            # Check token usage and cost
/compact                         # Free up context when it gets large
Alt+T                            # Toggle extended thinking for hard problems
Ctrl+C                           # Cancel current response

5. Kontynuacja później:

claude -c                        # Resume your most recent session
claude --resume                  # Pick from session list

Wskazówka eksperta: Warto utworzyć plik CLAUDE.md w katalogu głównym projektu z poleceniami budowania, konwencjami kodowania i notatkami o architekturze. Claude czyta go przy każdej sesji — to najskuteczniejsza rzecz, jaką można zrobić dla jakości.

Podstawowe tryby interakcji

Interaktywny REPL

Uruchom Claude Code bez argumentów, aby wejść w interaktywną pętlę odczyt-ewaluacja-wydruk:

cd your-project
claude

REPL zachowuje kontekst rozmowy między kolejnymi zapytaniami. Wystarczy wpisać zapytanie, otrzymać odpowiedź i kontynuować pracę aż do wyjścia za pomocą /exit lub Ctrl+D.

Można rozpocząć sesję z początkowym zapytaniem, aby ukierunkować rozmowę:

claude "explain the authentication flow in this project"

Wskazówka eksperta: REPL zachowuje stan między zdarzeniami kompaktowania. Gdy kontekst staje się zbyt duży, Claude automatycznie podsumowuje starszą część rozmowy, zachowując kluczowe decyzje i fragmenty kodu. Można to wywołać ręcznie za pomocą /compact lub dodać własne instrukcje określające, co należy zachować.

Tryb nieinteraktywny

Tryb wydruku (-p) wykonuje pojedyncze zapytanie i kończy działanie:

# Direct query
claude -p "list all TODO comments in this project"

# Process piped input
cat error.log | claude -p "identify the root cause of these failures"

# Chain with other tools
claude -p "generate a README" > README.md

Aby uzyskać ustrukturyzowane dane wyjściowe odpowiednie do przetwarzania w skryptach:

claude -p "count lines by file type" --output-format json

Dane wyjściowe w formacie JSON zawierają wszystko, co potrzebne do automatyzacji:

{
  "type": "result",
  "subtype": "success",
  "total_cost_usd": 0.0034,
  "is_error": false,
  "duration_ms": 2847,
  "duration_api_ms": 1923,
  "num_turns": 4,
  "result": "Response text here...",
  "session_id": "abc-123-def"
}

Aby przetwarzać strumieniowe dane wyjściowe w czasie rzeczywistym:

claude -p "build the application" --output-format stream-json | while read line; do
  echo "$line" | jq -r 'select(.result) | .result'
done

Opcje formatu danych wyjściowych:

Kody zakończenia:

Kontrola zachowania agentowego w trybie -p:

# Limit autonomous turns (prevents runaway loops)
claude -p "refactor the auth module" --max-turns 10

# Allow specific tools without prompting
claude -p "fix lint errors" --allowedTools "Edit,Bash(npm run lint)"

# Use with a specific model
claude -p "explain this code" --model claude-sonnet-4-5-20250929

Wzorzec integracji z CI/CD:

# In a GitHub Action or CI pipeline
result=$(claude -p "review this diff for security issues" --output-format json 2>/dev/null)
is_error=$(echo "$result" | jq -r '.is_error')
if [ "$is_error" = "true" ]; then
  echo "Review failed"
  exit 1
fi
echo "$result" | jq -r '.result'

Zarządzanie sesjami

Sesje przechowują historię rozmów w celu ich kontynuacji. Trwałość sesji jest niezbędna przy złożonej pracy wielosesyjnej:

# Continue most recent session
claude -c

# Continue with additional prompt
claude -c -p "now add error handling"

# Resume specific session by ID
claude -r "abc123" "implement the remaining tests"

# Fork a session for parallel exploration
claude -r "base-session" --fork-session "try a different approach"

Sesje powiązane z PR (v2.1.27+): Można rozpocząć sesję powiązaną z konkretnym pull requestem:⁸¹

claude --from-pr 123                                    # By PR number
claude --from-pr https://github.com/org/repo/pull/123   # By URL

Sesje automatycznie łączą się z PR-ami również wtedy, gdy zostaną one utworzone za pomocą gh pr create podczas sesji. Ułatwia to późniejsze wznowienie pracy nad konkretnym PR-em.

Nazwane sesje: Można nadać sesji nazwę przy uruchomieniu lub w trakcie jej trwania:

# Name session at startup (v2.1.76+)
claude -n "auth-refactor"                  # --name flag sets display name[^125]

# Name current session
> /rename auth-refactor

# Resume by name or number
> /resume 1                    # Resume first session
> /resume auth-refactor        # Resume by name
claude --resume auth-refactor  # Resume from terminal
claude -r 3                    # Resume by number from terminal

# Fork for parallel exploration
claude --resume auth-refactor --fork-session

Uwaga: --session-id wymaga prawidłowego UUID (np. 550e8400-e29b-41d4-a716-446655440000). Aby nadawać sesjom czytelne nazwy, należy używać /rename i --resume.

Claude Code przechowuje sesje jako transkrypcje JSONL. Wykonanie agenta przypisuje unikalne wartości agentId, a transkrypcje są zapisywane jako agent-{agentId}.jsonl. Wznowienie sesji zachowuje pełny kontekst z poprzednich rozmów.

Tryb planowania

Tryb planowania ogranicza Claude do eksploracji w trybie tylko do odczytu — bez edycji plików, bez wykonywania poleceń bash, bez destrukcyjnych operacji. Claude projektuje podejście do implementacji, zapisuje je w pliku planu i czeka na zatwierdzenie przed wykonaniem czegokolwiek.

Wchodzenie w tryb planowania:

# Cycle through modes during a session
Shift+Tab           # Cycles: normal → plan → auto-accept

# Or use the /plan command with an optional description (v2.1.72+)
/plan                                     # Enter plan mode
/plan refactor the auth module            # Enter plan mode with a description

# Or ask Claude directly
"Plan how to refactor the auth module"   # Claude may enter plan mode automatically

Jak to działa:

1. Claude wchodzi w tryb planowania (automatycznie dla złożonych zadań lub za pomocą Shift+Tab)
2. Eksploruje bazę kodu przy użyciu narzędzi tylko do odczytu: Read, Glob, Grep, WebSearch, WebFetch
3. Zapisuje plan do .claude/plans/{session-slug}.md
4. Wychodzi z trybu planowania za pomocą ExitPlanMode, przedstawiając plan do przeglądu
5. Użytkownik zatwierdza, prosi o zmiany lub odrzuca

Dostępne narzędzia w trybie planowania: Read, Glob, Grep, LS, WebSearch, WebFetch, AskUserQuestion. Narzędzia edycyjne (Edit, Write, Bash, NotebookEdit) są zablokowane.

Po zatwierdzeniu planu (v2.1.32+): Claude oferuje trzy opcje: - „Tak, wyczyść kontekst i automatycznie akceptuj edycje” (Shift+Tab) — rozpoczyna od nowa z pełnym kontekstem dla planu - „Tak, i ręcznie zatwierdzaj edycje” — zachowuje kontekst, użytkownik zatwierdza każdą zmianę - „Tak, automatycznie akceptuj edycje” — zachowuje kontekst, Claude wykonuje bez zatwierdzania poszczególnych edycji

Automatyczne czyszczenie kontekstu przy zatwierdzeniu to zalecany przepływ pracy. Daje planowi świeże okno kontekstowe, co znacząco poprawia zgodność z planem — Claude dłużej trzyma się wyznaczonego kursu, bez zakłóceń ze strony starszej rozmowy.

Kiedy używać trybu planowania: - Implementacja nowych funkcji wymagających decyzji architektonicznych - Refaktoryzacja wielu plików, gdy chce się najpierw przejrzeć podejście - Nieznane bazy kodu, gdzie eksploracja powinna poprzedzać modyfikację - Każde zadanie, w którym istnieje wiele prawidłowych podejść i potrzebne są wstępne ustalenia

Wskazówka eksperta: Im więcej czasu poświęci się na tryb planowania, tym większe prawdopodobieństwo, że Claude pomyślnie przeprowadzi implementację. Tryb planowania to w zasadzie darmowa eksploracja — bez ryzykownych wywołań narzędzi, bez zmarnowanych edycji. Warto korzystać z niego bez ograniczeń.

Szczegółowy przegląd systemu konfiguracji

Claude Code wykorzystuje warstwowy system konfiguracji. Zrozumienie hierarchii jest kluczowe, ponieważ wyższe poziomy nadpisują niższe, a ustawienia korporacyjne nie mogą być w ogóle pominięte.

Hierarchia konfiguracji

Wskazówka eksperta: Należy używać .claude/settings.local.json do osobistych preferencji we współdzielonych projektach (dodając plik do .gitignore). .claude/settings.json służy do konfiguracji zespołowej, która jest commitowana do repozytorium.

Kompletna dokumentacja settings.json

Pełna konfiguracja prezentująca wszystkie główne opcje:

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "claude-sonnet-4-5-20250929",
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)",
      "Bash(make:*)",
      "Edit(src/**)",
      "Write(src/**)",
      "mcp__github"
    ],
    "deny": [
      "Read(.env*)",
      "Read(secrets/**)",
      "Bash(rm -rf:*)",
      "Bash(sudo:*)",
      "Edit(package-lock.json)",
      "Edit(.git/**)"
    ],
    "ask": [
      "WebFetch",
      "Bash(curl:*)",
      "Bash(docker:*)"
    ],
    "additionalDirectories": [
      "../shared-lib",
      "../docs"
    ],
    "defaultMode": "acceptEdits"
  },
  "env": {
    "NODE_ENV": "development",
    "DEBUG": "app:*"
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ]
  },
  "sandbox": {
    "enabled": false,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"]
  },
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  },
  "includeCoAuthoredBy": true,
  "cleanupPeriodDays": 30,
  "outputStyle": "Explanatory",
  "language": "en",
  "respectGitignore": true,
  "showTurnDuration": true,
  "plansDirectory": ".claude/plans",
  "spinnerVerbs": ["Thinking", "Processing", "Analyzing"],
  "spinnerTipsOverride": {
    "tips": ["Custom tip 1", "Custom tip 2"],
    "excludeDefault": true
  },
  "includeGitInstructions": false,
  "modelOverrides": {
    "bedrock": "us.anthropic.claude-opus-4-6-20260312-v1:0",
    "vertex": "claude-opus-4-6@20260312",
    "foundry": "anthropic.claude-opus-4-6"
  },
  "autoMemoryDirectory": ".claude/memory",
  "sandbox": {
    "enableWeakerNetworkIsolation": true
  }
}

Dokumentacja zmiennych środowiskowych

Uwierzytelnianie i API:

ANTHROPIC_API_KEY=sk-ant-...                    # Direct API authentication
ANTHROPIC_AUTH_TOKEN=token                      # Custom authorization header
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Additional request headers

Konfiguracja modelu:

ANTHROPIC_MODEL=claude-opus-4-6                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-6    # Opus 4.6 (Feb 2026)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model for subagents
MAX_THINKING_TOKENS=10000                       # Enable extended thinking
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Limit output length
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1          # Enable agent teams (v2.1.32+)

Konfiguracja dostawców chmurowych:

CLAUDE_CODE_USE_BEDROCK=1                       # Use AWS Bedrock
CLAUDE_CODE_USE_VERTEX=1                        # Use Google Vertex AI
CLAUDE_CODE_USE_FOUNDRY=1                       # Use Microsoft Foundry
ANTHROPIC_BEDROCK_BASE_URL=https://...          # Custom Bedrock endpoint
CLAUDE_CODE_SKIP_BEDROCK_AUTH=1                 # Skip Bedrock auth (for gateways)
CLAUDE_CODE_SKIP_VERTEX_AUTH=1                  # Skip Vertex auth
AWS_BEARER_TOKEN_BEDROCK=token                  # Bedrock bearer token
VERTEX_REGION_CLAUDE_3_7_SONNET=us-west1        # Override Vertex region

Sterowanie zachowaniem:

DISABLE_AUTOUPDATER=1                           # Prevent automatic updates
DISABLE_TELEMETRY=1                             # Opt out of usage telemetry
DISABLE_ERROR_REPORTING=1                       # Disable Sentry
DISABLE_BUG_COMMAND=1                           # Disable /bug command
DISABLE_COST_WARNINGS=1                         # Hide cost warnings
DISABLE_PROMPT_CACHING=1                        # Disable prompt caching globally
DISABLE_PROMPT_CACHING_SONNET=1                 # Disable for Sonnet only
DISABLE_PROMPT_CACHING_OPUS=1                   # Disable for Opus only
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Skip non-critical API calls

Konfiguracja narzędzi:

BASH_DEFAULT_TIMEOUT_MS=30000                   # Bash command timeout (30s)
BASH_MAX_TIMEOUT_MS=600000                      # Maximum bash timeout (10min)
BASH_MAX_OUTPUT_LENGTH=50000                    # Bash output limit
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # Reset CWD after each bash
MCP_TIMEOUT=5000                                # MCP server startup timeout
MCP_TOOL_TIMEOUT=30000                          # MCP tool execution timeout
MAX_MCP_OUTPUT_TOKENS=25000                     # MCP output limit
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Slash command context limit

Sieć i proxy:

HTTP_PROXY=http://proxy:8080                    # HTTP proxy
HTTPS_PROXY=https://proxy:8080                  # HTTPS proxy
NO_PROXY=localhost,example.com                  # Bypass proxy for domains
CLAUDE_CODE_CLIENT_CERT=/path/to/cert           # mTLS certificate
CLAUDE_CODE_CLIENT_KEY=/path/to/key             # mTLS private key
CLAUDE_CODE_CLIENT_KEY_PASSPHRASE=pass          # mTLS passphrase

Interfejs użytkownika i terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Disable 1M context window (use standard 200K)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Plugin marketplace git timeout (default 120s, was 30s)[^105]
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1        # Remove built-in commit/PR instructions[^117]
CLAUDE_CODE_DISABLE_CRON=1                    # Stop scheduled cron jobs mid-session[^121]
CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=30000 # SessionEnd hooks timeout (default varies)[^123]

Zmienne skills (v2.1.69+):

${CLAUDE_SKILL_DIR}                            # Self-reference for skills to locate their own directory[^117]

Tożsamość wywołującego SDK (v2.1.51+):

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Provide account UUID synchronously for SDK callers
CLAUDE_CODE_USER_EMAIL=[email protected]        # Provide user email for SDK callers
CLAUDE_CODE_ORGANIZATION_UUID=uuid             # Provide organization UUID for SDK callers

Debugowanie:

ANTHROPIC_LOG=debug                             # Enable API request logging

Który model wybrać?

Wybór odpowiedniego modelu do każdego zadania ma istotny wpływ zarówno na koszty, jak i na jakość. Claude Code umożliwia elastyczne przełączanie modeli na wielu poziomach.

Dostępne modele

Opus 4.6 (5 lutego 2026): Najnowszy flagowy model z oknem kontekstowym 1M tokenów, maksymalnym wyjściem 128K, adaptacyjnym myśleniem i zespołami agentów.⁸⁶ Ceny takie same jak Opus 4.5 ($5/$25 za MTok). Od wersji v2.1.75 (13 marca 2026) okno kontekstowe 1M jest domyślnie włączone dla planów Max, Team i Enterprise — sufiks [1m] nie jest już wymagany dla tych poziomów.¹²⁴ Od wersji v2.1.77 (17 marca 2026) domyślny limit tokenów wyjściowych dla Opus 4.6 został zwiększony do 64K tokenów, z górnym limitem 128K tokenów.¹²⁶ Długi kontekst (>200K tokenów wejściowych) przy użyciu wyłącznie API nadal kosztuje $10/$37,50 za MTok. ID modelu: claude-opus-4-6.¹

Sonnet 4.6 (17 lutego 2026): Nowy zrównoważony model zastępujący Sonnet 4.5 jako domyślny na claude.ai i Claude Cowork.¹⁰⁰ Ceny takie same jak Sonnet 4.5 ($3/$15 za MTok). Ulepszone agentowe wyszukiwanie przy mniejszym zużyciu tokenów. Obsługuje rozszerzone myślenie, adaptacyjne myślenie i okno kontekstowe 1M tokenów (beta). Maksymalne wyjście 64K (górny limit zwiększony do 128K w v2.1.77).¹²⁶ Granica wiedzy: sierpień 2025 (wiarygodne dane), styczeń 2026 (dane treningowe). ID modelu: claude-sonnet-4-6. Sonnet 4.5 jest teraz modelem starszej generacji.¹⁰⁰

Dlaczego te różnice cenowe mają znaczenie: Typowa sesja programistyczna zużywa 50K–200K tokenów wejściowych i 10K–50K tokenów wyjściowych. Z Haiku to $0,10–$0,45 za sesję. Z Opus ta sama sesja kosztuje $0,50–$2,25, czyli 5 razy więcej. Opus warto zarezerwować dla naprawdę trudnych problemów.¹

Kiedy używać poszczególnych modeli

Haiku: Idealny dla subagentów wykonujących eksplorację, proste wyszukiwania plików i szybkie pytania. Jest ~5 razy tańszy od Opus i odpowiada szybciej. Doskonały do zadań w tle, gdzie głębokie rozumowanie nie jest potrzebne.

Sonnet: Koń roboczy codziennego programowania. Radzi sobie z większością zadań: implementacją funkcji, naprawianiem błędów, pisaniem testów, przeglądem kodu. Warto używać go jako domyślnego modelu. Sonnet 4.6 (luty 2026) oferuje ulepszone agentowe wyszukiwanie i lepszą efektywność tokenową w porównaniu z Sonnet 4.5, z obsługą adaptacyjnego myślenia i oknem kontekstowym 1M w wersji beta.¹⁰⁰

Opus: Należy zarezerwować dla naprawdę złożonego rozumowania: decyzji architektonicznych, trudnego debugowania, analizy złożonych systemów, audytów bezpieczeństwa. Opus 4.6 (luty 2026) to znaczący krok naprzód: planuje staranniej, dłużej utrzymuje zadania agentowe, działa bardziej niezawodnie w dużych bazach kodu i lepiej wychwytuje własne błędy podczas przeglądu kodu.⁸⁶ Oferuje okno kontekstowe 1M tokenów w wersji beta i wprowadza adaptacyjne myślenie, które automatycznie dobiera głębokość rozumowania. Według Anthropic, w teście Terminal-Bench 2.0 Opus 4.6 osiąga najwyższy w branży wynik agentowego kodowania. W teście GDPval-AA (ekonomicznie wartościowa praca intelektualna) Anthropic podaje, że przewyższa GPT-5.2 o ~144 punkty Elo.⁸⁶ Uwaga: Użytkownicy subskrypcji Pro mają dostęp do Opus w ramach swojej subskrypcji.²⁰

Opusplan: Tryb hybrydowy, który wykorzystuje Opus do planowania (gdzie jakość rozumowania ma największe znaczenie) i Sonnet do wykonania (gdzie liczy się szybkość). Doskonały do złożonych refaktoryzacji, gdy potrzebny jest najlepszy plan, ale nie jest wymagane rozumowanie na poziomie Opus dla każdej pojedynczej edycji.

Przełączanie modeli

Podczas sesji:

> /model opus
> /model sonnet
> /model haiku

Przy uruchomieniu:

claude --model opus

Przez zmienną środowiskową:

export ANTHROPIC_MODEL=opus

W settings.json:

{
  "model": "claude-sonnet-4-5-20250929"
}

Dla subagentów:

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Rozszerzony kontekst

Dla dużych baz kodu lub długich sesji można włączyć kontekst 1M tokenów:

claude --model sonnet[1m]
claude --model opus[1m]           # Opus 4.6 with 1M context

Lub w trakcie sesji:

> /model sonnet[1m]
> /model opus[1m]

Od wersji v2.1.75 (13 marca 2026) Opus 4.6 domyślnie używa kontekstu 1M dla planów Max, Team i Enterprise — sufiks [1m] nie jest potrzebny.¹²⁴ Sufiks [1m] jest nadal wymagany dla Sonnet i dla użytkowników korzystających wyłącznie z API.

Opus 4.6 to pierwszy model klasy Opus z natywną obsługą kontekstu 1M. Osiąga 76% dokładności w wariancie 8-igłowym 1M testu MRCR v2 (konkurencja osiąga ~18,5%), co czyni go najsilniejszym modelem do wyszukiwania w długim kontekście.⁸⁶

Rozszerzony kontekst kosztuje więcej za token (2x wejście, 1,5x wyjście przy >200K tokenów wejściowych). W przypadku Sonnet z [1m] warto go używać tylko wtedy, gdy jest rzeczywiście potrzebny, a nie jako domyślne ustawienie.

Sprawdzanie bieżącego modelu

> /status

To polecenie wyświetla bieżący model, informacje o koncie, zastosowane ustawienia i inny stan sesji.

Etykiety w selektorze modeli (v2.1.51+): Selektor /model wyświetla teraz czytelne etykiety (np. „Sonnet 4.6”) zamiast surowych identyfikatorów modeli dla przypiętych wersji, z podpowiedziami o aktualizacji, gdy dostępne są nowsze wersje.¹⁰⁵

Tryb szybki (v2.1.36+)

Tryb szybki zapewnia znacznie szybsze generowanie odpowiedzi z tego samego modelu — nie przełącza na tańszy model. Można go włączać i wyłączać w trakcie sesji poleceniem /fast.⁹³

> /fast            # Toggle fast mode on/off

Cennik (tryb szybki Opus 4.6):

Cennik trybu szybkiego obowiązuje w całym oknie kontekstowym, łącznie z żądaniami przekraczającymi 200K tokenów wejściowych — w trybie szybkim nie ma dodatkowej dopłaty za długi kontekst.¹ Cennik trybu szybkiego łączy się z buforowaniem promptów i mnożnikami rezydencji danych, ale NIE z cennikiem długiego kontekstu. Tryb szybki nie jest dostępny z API Batch.

Kiedy używać trybu szybkiego: - Szybka iteracja nad drobnymi zmianami, gdy opóźnienie stanowi wąskie gardło - Generowanie testów, szablonów lub powtarzalnego kodu, gdzie szybkość jest ważniejsza niż koszt - Sekwencyjne przechodzenie przez listę podobnych zadań

Kiedy NIE używać trybu szybkiego: - Długotrwałe zadania agentowe (koszty szybko rosną przy 6-krotnej stawce) - Praca subagentów w tle (nikt nie czeka na wynik) - Sesje z ograniczonym budżetem

Tryb szybki Opus 4.6 obejmuje teraz pełne okno kontekstowe 1M (v2.1.50+). Wcześniej tryb szybki był ograniczony do standardowego kontekstu; teraz zapewnia tę samą pojemność 1M tokenów z prędkością trybu szybkiego.¹⁰³

Wskazówka eksperta: Tryb szybki dobrze współgra z trybem hybrydowym opusplan: można go włączyć podczas fazy wykonania przez Sonnet dla szybkiej iteracji, zachowując standardowe stawki dla planowania przez Opus. Należy pamiętać, że /fast wymaga wcześniejszego włączenia /extra-usage (poprawka w v2.1.37).⁹³

Ile kosztuje Claude Code?

Zrozumienie i kontrolowanie kosztów jest kluczowe dla zrównoważonego korzystania z Claude Code. Zobacz także Wybór modelu, aby poznać możliwości modeli, oraz Ramy decyzyjne, aby wybrać odpowiedni model do danego zadania.

Sprawdzanie kosztów

> /cost

Wynik:

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    247 lines added, 89 lines removed

Plany subskrypcyjne

Limity częstotliwości (sierpień 2025): Anthropic wprowadził tygodniowe limity częstotliwości dla płatnych subskrybentów. Subskrybenci Max mogą dokupić dodatkowe wykorzystanie ponad limit po standardowych stawkach API.²¹

Cennik tokenów API (luty 2026)¹⁸⁶

Dla użytkowników rozliczanych przez API, cena za milion tokenów:

Cennik długiego kontekstu (>200K tokenów wejściowych):

Próg 200K opiera się na łącznej liczbie tokenów wejściowych (włącznie z odczytami/zapisami cache). Po jego przekroczeniu Anthropic nalicza opłaty za wszystkie tokeny według stawki za długi kontekst.¹

Cennik rezydencji danych: Określenie inferencji wyłącznie w USA za pomocą inference_geo dodaje mnożnik 1,1× do wszystkich cen tokenów (tylko modele Opus 4.6+).¹

Prompt caching znacząco obniża koszty powtarzających się danych wejściowych: zapis do cache kosztuje 1,25× stawki bazowej (cache 5-minutowy) lub 2× (cache 1-godzinny), ale odczyt z cache kosztuje tylko 0,1× — oszczędność 90%. Dla systemów RAG i asystentów kodu z powtarzającym się kontekstem caching może obniżyć koszty o 88-95%.

Batch API oferuje 50% zniżki przy 24-godzinnym czasie realizacji dla zadań niepilnych, takich jak nocne zestawy testów.

Zasady dotyczące wielu kont⁵⁹

Czy można mieć wiele kont Claude? Tak, w przypadku uzasadnionych zastosowań. Anthropic wyraźnie zezwala na wiele kont, gdy służą one różnym celom.

Co jest dozwolone:

Limity techniczne: - Do 3 kont może być zweryfikowanych tym samym numerem telefonu - Wiele płatnych subskrypcji z tego samego IP/sieci jest wyraźnie obsługiwane - Konta są całkowicie oddzielne; nie ma możliwości przenoszenia czatów ani projektów między nimi

Co jest zabronione (zgodnie z Polityką użytkowania): - Tworzenie kont w celu obejścia banów po zbanowaniu - Koordynowanie złośliwej aktywności między kontami w celu uniknięcia wykrycia - Używanie wielu kont do obchodzenia limitów częstotliwości lub kredytów darmowego planu

Uwaga z praktyki: W styczniu 2026 roku power user Jeffrey Emanuel (@doodlestein) miał 22 konta Max automatycznie oznaczone i tymczasowo zbanowane. Pracownik Anthropic Thariq (@trq212) rozwiązał sprawę w ciągu 4 godzin po potwierdzeniu uzasadnionego użytkowania. Jeśli intensywnie korzystasz z Claude Code zarówno do pracy, jak i projektów prywatnych na wielu kontach — dokładnie do tego usługa została zaprojektowana, ale nie próbuj oszukiwać systemu.

W razie wątpliwości: Skontaktuj się z Pomocą techniczną Anthropic, aby potwierdzić swoją konkretną konfigurację na piśmie.

Czynniki wpływające na koszty

Przykłady kosztów z praktyki

Wskazówka dotycząca oszczędności: Używanie Haiku do subagentów eksploracyjnych i Sonnet do implementacji zwykle obniża koszty o 40-50% w porównaniu z używaniem Sonnet do wszystkiego.

Zarządzanie kosztami zespołu

Zalecane TPM/RPM według wielkości zespołu:

Ukryte opłaty za narzędzia

Poza ceną za token niektóre narzędzia generują dodatkowe opłaty:¹⁶

Koszty te kumulują się w pętlach agentów. 100-iteracyjny cykl debugowania z Bash generuje ~24 500 dodatkowych tokenów wejściowych samego narzutu.

Strategie oszczędzania kosztów

1. Używaj Haiku do subagentów: Większość eksploracji nie wymaga Sonnet
2. Włącz prompt caching: Domyślnie włączony, ale upewnij się, że nie jest wyłączony
3. Ustaw maksymalną liczbę tur: claude --max-turns 5 zapobiega niekontrolowanym konwersacjom
4. Używaj trybu planowania do eksploracji: Brak wykonywania = brak przypadkowych kosztownych operacji
5. Kompaktuj proaktywnie: Mniejszy kontekst = mniej tokenów
6. Ogranicz wyjście: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch API dla niepilnych zadań: 50% zniżki zarówno na tokeny wejściowe, jak i wyjściowe

Monitorowanie wykorzystania

• Konsola Claude: platform.claude.com (wymaga roli Admin lub Billing)
• Limity przestrzeni roboczej: Ustaw limity wydatków na przestrzeń roboczą
• Bedrock/Vertex: Korzystaj z natywnego monitorowania kosztów w chmurze
• LiteLLM: Do szczegółowego śledzenia per użytkownik u dostawców zewnętrznych

Wykorzystanie tokenów w tle

Niektóre operacje zużywają tokeny w tle: - Podsumowywanie konwersacji dla /resume - Polecenia /cost i /status - Automatyczna kompaktacja

Zazwyczaj poniżej 0,04 $ na sesję.

Claude Code Analytics API (Team/Enterprise)⁵³

Programistyczny dostęp do analityki wykorzystania Claude Code i metryk produktywności organizacji za pośrednictwem Admin API.

Endpoint: GET /v1/organizations/usage_report/claude_code

Wymagania: - Klucz Admin API (sk-ant-admin...) - Plan Team lub Enterprise - Rola Admin, Billing lub Developer

Dostępne metryki:

Przykładowe żądanie:

curl "https://api.anthropic.com/v1/organizations/usage_report/claude_code?starting_at=2026-01-15" \
  -H "x-api-key: sk-ant-admin..." \
  -H "anthropic-version: 2023-06-01"

Zastosowania: - Analiza produktywności programistów (sesje, commity, PR) - Metryki wykorzystania narzędzi (wskaźniki akceptacji/odrzucenia dla Edit, Write itp.) - Śledzenie i alokacja kosztów między zespołami - Uzasadnienie ROI dla narzędzi kodowania AI

Uwaga: Dane pojawiają się w ciągu 1 godziny od zakończenia aktywności. Dla zachowania spójności w odpowiedziach uwzględniane są wyłącznie dane starsze niż 1 godzina.

Ramki decyzyjne

Sama znajomość funkcji nie wystarczy. Trzeba wiedzieć, kiedy użyć każdej z nich. Te drzewa decyzyjne przekształcają wiedzę w działanie.

Którego modelu użyć?

START → Czy zadanie jest proste? (wyszukiwanie plików, szybkie pytanie, formatowanie)
         │
         ├── TAK → Użyj Haiku
         │         Koszt: ~0,03 $/zadanie
         │         Szybkość: Najwyższa
         │
         └── NIE → Czy wymaga głębokiego rozumowania?
                  (architektura, złożone debugowanie, analiza bezpieczeństwa)
                  │
                  ├── TAK → Użyj Opus 4.6
                  │         Koszt: ~2,00 $/zadanie
                  │         Jakość: Najwyższa (kontekst 1M, adaptacyjne myślenie)
                  │
                  └── NIE → Użyj Sonnet (domyślny)
                           Koszt: ~0,75 $/zadanie
                           Równowaga: Najlepszy ogólnie

Zasada ogólna: Zacznij od Sonnet. Przejdź na Haiku dla subagentów. Eskaluj do Opus 4.6 tylko wtedy, gdy odpowiedź Sonnet wydaje się powierzchowna. Dzięki zespołom agentów (v2.1.32+) Opus może koordynować wielu agentów pracujących równolegle nad różnymi podzadaniami.⁸⁶

Polecenie, skill, subagent czy zespół agentów?

Czy chcesz mieć jawną kontrolę nad momentem uruchomienia?
│
├── TAK → Użyj Slash Command
│         Przykład: /deploy, /test, /security-review
│         Sam decydujesz o wywołaniu i momencie.
│
└── NIE → Czy ekspertyza powinna być stosowana automatycznie na podstawie kontekstu?
         │
         ├── TAK → Użyj Skill
         │         Przykład: Wzorce bezpieczeństwa, reguły domenowe, standardy kodu
         │         Claude rozpoznaje kontekst i stosuje wiedzę ekspercką.
         │
         └── NIE → Czy praca wymaga izolowanego kontekstu?
                  │
                  ├── TAK → Jedno podzadanie czy wiele równoległych podzadań?
                  │         │
                  │         ├── JEDNO → Użyj subagenta (narzędzie Task)
                  │         │         Przykład: Dogłębna eksploracja, równoległa analiza
                  │         │         Zapobiega rozrostowi kontekstu w głównej konwersacji.
                  │         │
                  │         └── WIELE → Użyj zespołu agentów (v2.1.32+)
                  │                   Przykład: 5 agentów recenzujących różne moduły jednocześnie
                  │                   Opus koordynuje; każdy agent pracuje niezależnie.
                  │
                  └── NIE → Po prostu zadaj pytanie bezpośrednio
                           Nie wszystko wymaga abstrakcji.

Hook czy prompt?

Czy akcja MUSI się wykonać ZAWSZE, niezależnie od oceny Claude?
│
├── TAK → Użyj Hook (deterministyczny)
│         Przykłady:
│         - Formatuj kod po każdej edycji
│         - Loguj wszystkie polecenia bash
│         - Blokuj dostęp do plików .env
│         Claude nie może pominąć, zapomnieć ani zdecydować inaczej.
│
└── NIE → Użyj Prompt (probabilistyczny)
         Przykłady:
         - „Rozważ dodanie testów"
         - „Pomyśl o przypadkach brzegowych"
         - „Sprawdź pod kątem bezpieczeństwa, jeśli to zasadne"
         Claude decyduje na podstawie kontekstu.

Kiedy używać rozszerzonego myślenia?

Czy to naprawdę trudny problem?
│
├── Decyzja architektoniczna z wieloma kompromisami → TAK, użyj myślenia
├── Złożone debugowanie z niejasną przyczyną → TAK, użyj myślenia
├── Analiza bezpieczeństwa wymagająca starannego rozumowania → TAK, użyj myślenia
├── Poznawanie nieznanej bazy kodu → TAK, użyj myślenia
│
├── Rutynowa naprawa błędu → NIE, pomiń myślenie
├── Prosty refactoring → NIE, pomiń myślenie
├── Formatowanie kodu → NIE, pomiń myślenie
└── Szybkie pytania → NIE, pomiń myślenie

Przełączaj za pomocą Alt+T podczas sesji. Wyższe budżety myślenia kosztują więcej; zacznij od minimum i zwiększaj tylko wtedy, gdy odpowiedzi wydają się pospieszne.

Adaptacyjne myślenie Opus 4.6: Opus 4.6 automatycznie dostosowuje głębokość myślenia do złożoności problemu. W przypadku większości zadań jawna kontrola budżetu myślenia nie jest konieczna — Opus skaluje się w górę dla trudnych problemów i pozostaje szybki dla prostych. Ręczne przełączanie myślenia jest najbardziej przydatne w przypadku Sonnet, gdy chcesz wymusić głębszą analizę.

Która powierzchnia wykonawcza?

Gdzie ta praca powinna się odbywać?
│
├── Wymaga TWOICH lokalnych plików i narzędzi
│   │
│   ├── Interaktywna, iteracyjna praca → Główna sesja REPL
│   ├── Jednorazowe zadanie skryptowe → claude -p "prompt" (tryb print)
│   ├── Automatyzacja CI/CD → claude -p --json (nieinteraktywny + ustrukturyzowane wyjście)
│   └── Równoległe izolowane zadania → Subagenty przez narzędzie Task
│
├── Wymaga CZYJEGOŚ INNEGO środowiska
│   │
│   └── Zdalna baza kodu lub serwer → Agent w tle (chmura)
│
└── Nie wymaga żadnego środowiska
    │
    ├── Badania lub analiza → Subagent typu Explore
    └── Ekstrakcja treści z sieci → Narzędzia WebFetch / WebSearch

Zespoły agentów, subagenty czy sesje równoległe

Czy potrzebujesz wielu agentów pracujących nad powiązanymi podzadaniami?
│
├── TAK → Czy podzadania są niezależne (brak współdzielonego stanu)?
│         │
│         ├── TAK → Czy mogą współdzielić tę samą bazę kodu?
│         │         │
│         │         ├── TAK → Użyj zespołu agentów (v2.1.32+)
│         │         │         Opus koordynuje. Agenty współdzielą dostęp do repozytorium.
│         │         │         Przykład: „Sprawdź moduły auth, API i DB równolegle"
│         │         │
│         │         └── NIE → Użyj sesji równoległych (osobne terminale)
│         │                  Każda ma własny katalog roboczy.
│         │                  Przykład: „Napraw repo-A i repo-B jednocześnie"
│         │
│         └── NIE → Użyj sekwencyjnych subagentów
│                  Wyniki jednego zasilają kolejnego.
│                  Przykład: „Explore → Plan → Implement"
│
└── NIE → Użyj pojedynczego subagenta lub głównego REPL

Który typ hook?

Jakiego rodzaju automatyzacji potrzebujesz?
│
├── Uruchomić polecenie powłoki przy określonym zdarzeniu?
│   │
│   └── Użyj Command Hook
│       Wyzwalacz: PreToolUse, PostToolUse, Notification, Stop, SubagentStop
│       Przykład: „Uruchom prettier po każdej edycji pliku"
│       Konfiguracja: hooks.PostToolUse[].command = "prettier --write $FILE"
│
├── Modyfikować prompt systemowy Claude na podstawie kontekstu?
│   │
│   └── Użyj Prompt Hook (v2.1.35+)
│       Wyzwalacz: Te same zdarzenia
│       Przykład: „Wstrzyknij reguły projektu podczas pracy w /src/auth/"
│       Konfiguracja: hooks.PreToolUse[].prompt = "When editing auth files..."
│
└── Pozwolić Claude podjąć decyzję przed kontynuacją?
    │
    └── Użyj Agent Hook (v2.1.35+)
        Wyzwalacz: Te same zdarzenia
        Przykład: „Oceń, czy to polecenie bash jest bezpieczne przed uruchomieniem"
        Konfiguracja: hooks.PreToolUse[].agent = { prompt: "Is this safe?" }

Kiedy używać /fast?

Czy szybkość odpowiedzi jest teraz ważniejsza niż głębia?
│
├── TAK → Użyj /fast
│         Ten sam model Opus 4.6, szybsze wyjście
│         Dobre do: szybkich pytań, prostych edycji, wyjaśnień kodu,
│                   wyszukiwania plików, zadań formatowania
│
└── NIE → Pozostań w trybie normalnym
         Dobre do: decyzji architektonicznych, złożonego debugowania,
                   przeglądów bezpieczeństwa, refaktoryzacji wielu plików,
                   wszystkiego wymagającego głębokiego rozumowania

/fast włącza tryb szybki dla bieżącej sesji. Używa tego samego modelu (Opus 4.6) ze zoptymalizowaną prędkością wyjścia — NIE przełącza na tańszy model.

Jak działa system uprawnień?

System uprawnień Claude Code zapewnia szczegółową kontrolę nad tym, jakie operacje mogą być wykonywane. Zrozumienie go jest niezbędne zarówno dla bezpieczeństwa, jak i efektywności pracy. Więcej informacji na temat zarządzanych ustawień wymuszających uprawnienia w całej organizacji znajduje się w sekcji Wdrożenie korporacyjne.

Poziomy uprawnień

Narzędzia tylko do odczytu (automatycznie zatwierdzane): - Read — odczyt zawartości plików - Glob — wyszukiwanie plików według wzorca - Grep — przeszukiwanie zawartości plików - WebSearch — wyszukiwanie w internecie - LSP — inteligencja kodu (przejście do definicji, znajdowanie referencji, dokumentacja po najechaniu)²⁵

Możliwości narzędzia LSP (v2.0.74+): Narzędzie LSP zapewnia inteligencję kodu na poziomie IDE: - Przejście do definicji: przejście do miejsca, w którym zdefiniowano symbol - Znajdowanie referencji: lista wszystkich użyć symbolu w całej bazie kodu - Dokumentacja po najechaniu: informacje o typie i dokumentacja dla dowolnego symbolu - Działa z TypeScript, Python, Go, Rust i innymi językami obsługującymi LSP - Wymaga dostępnego serwera językowego (zazwyczaj instalowanego wraz z zestawem narzędzi)

Narzędzia modyfikujące (wymagają zatwierdzenia): - Edit — modyfikacja istniejących plików - Write — tworzenie nowych plików - Bash — wykonywanie poleceń powłoki - WebFetch — pobieranie zawartości adresów URL - NotebookEdit — modyfikacja notatników Jupyter

Przy pierwszym uruchomieniu narzędzia modyfikującego Claude Code prosi o zatwierdzenie. Zatwierdzenia obowiązują przez całą sesję, chyba że skonfigurowano inaczej.

Tryby uprawnień

Tryb YOLO (v2.0.68+): W celu w pełni autonomicznej pracy można użyć flagi --dangerously-skip-permissions. Flaga ta zatwierdza wszystko: edycje plików, polecenia bash, wszystkie wywołania narzędzi. Słowo „dangerous” w nazwie jest zamierzone. Należy stosować wyłącznie w środowiskach piaskownicy lub gdy baza kodu jest w pełni zaufana.⁶¹

claude --dangerously-skip-permissions

Ustawianie trybu za pomocą CLI:

claude --permission-mode acceptEdits

Przełączanie podczas sesji:

Shift+Tab  # Przełącza między trybami

W pliku settings.json:

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Składnia reguł uprawnień

Szczegółowe reguły kontrolują konkretne operacje. Reguły są ewaluowane w kolejności: wygrywa pierwsze dopasowanie.

Wzorce poleceń Bash:

{
  "allow": [
    "Bash(npm run build)",
    "Bash(npm run test:*)",
    "Bash(git commit:*)",
    "Bash(make:*)"
  ],
  "deny": [
    "Bash(rm -rf:*)",
    "Bash(sudo:*)",
    "Bash(curl|wget:*)"
  ]
}

Gwiazdka zapewnia dopasowanie prefiksów: Bash(npm run test:*) zezwala na npm run test, npm run test:unit oraz npm run test:integration.

Ważne ograniczenie: Wzorce Bash dopasowują wyłącznie prefiksy, nie wyrażenia regularne. Wzorzec taki jak Bash(curl http:*) nie dopasuje curl -X GET http://..., ponieważ opcje występują przed adresem URL. Aby niezawodnie blokować polecenia, należy zablokować je całkowicie: Bash(curl:*).

Wzorce operacji na plikach:

{
  "allow": [
    "Edit(src/**)",
    "Write(src/**)",
    "Read(docs/**)"
  ],
  "deny": [
    "Read(.env*)",
    "Read(secrets/**)",
    "Edit(.git/**)",
    "Edit(node_modules/**)"
  ]
}

Składnia ścieżek: - Ścieżki względne: Edit(src/**) — względem katalogu roboczego - Bezwzględne od pliku ustawień: Edit(/build/**) — względem lokalizacji pliku ustawień - Prawdziwie bezwzględne: Edit(//tmp/**) — zaczynają się od // - Katalog domowy: Read(~/.zshrc)

Wzorce narzędzi MCP:

{
  "allow": [
    "mcp__github",
    "mcp__database__query",
    "mcp__myserver__*"
  ],
  "deny": [
    "mcp__dangerous_server",
    "mcp__untrusted__*"
  ]
}

Składnia z symbolem wieloznacznym mcp__server__* umożliwia zezwolenie lub zablokowanie wszystkich narzędzi z konkretnego serwera MCP.³⁹ Składnia wieloznaczna jest przydatna do szybkiego włączania wszystkich narzędzi z zaufanych serwerów lub blokowania całych serwerów z niezaufanych źródeł.

Wzorce WebFetch:

{
  "allow": [
    "WebFetch(domain:github.com)",
    "WebFetch(domain:api.example.com)"
  ]
}

Dodatkowe katalogi

Rozszerzenie dostępu Claude poza bieżący projekt:

{
  "permissions": {
    "additionalDirectories": [
      "../shared-lib",
      "../docs",
      "~/reference-projects/design-system"
    ]
  }
}

Dodatkowe katalogi są niezbędne w przypadku monorepo lub gdy Claude musi odwoływać się do kodu w sąsiednich katalogach.

Tryb piaskownicy

Włączanie izolacji systemu plików i sieci:

> /sandbox

Lub konfiguracja w ustawieniach:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true
    }
  }
}

W trybie piaskownicy: - Dostęp do systemu plików ograniczony do katalogu projektu - Kontrolowany dostęp do sieci - Określone polecenia wyłączone z ograniczeń piaskownicy - Polecenia Bash automatycznie zatwierdzane, gdy autoAllowBashIfSandboxed jest ustawione na true

Wskazówka ekspercka: Tryb piaskownicy doskonale sprawdza się przy pracy z niezaufanymi bazami kodu. Warto go włączyć podczas eksploracji nieznanych projektów lub gdy potrzebna jest dodatkowa warstwa ochrony. Wewnętrzne testy Anthropic wykazały, że piaskownica zmniejsza liczbę pytań o uprawnienia o 84%.⁴⁵ Piaskownica wykorzystuje mechanizmy na poziomie systemu operacyjnego (macOS seatbelt, Linux bubblewrap) do izolacji systemu plików i sieci, dzięki czemu nawet udany atak typu prompt injection jest w pełni odizolowany. Anthropic udostępnił kod źródłowy środowiska piaskownicy dla zespołów budujących własnych agentów.⁸⁹

Uwagi dotyczące bezpieczeństwa (v2.1.34+): Polecenia wyłączone z piaskownicy za pomocą sandbox.excludedCommands lub dangerouslyDisableSandbox mogły wcześniej omijać regułę pytania o uprawnienia Bash, gdy włączona była opcja autoAllowBashIfSandboxed; zostało to naprawione w wersji v2.1.34.⁹⁴ Od wersji v2.1.38 zapisy do .claude/skills są blokowane w trybie piaskownicy, co zapobiega modyfikowaniu definicji skills przez ataki prompt injection.⁹⁵ Wersja v2.1.77 dodaje ustawienie allowRead w konfiguracji systemu plików piaskownicy, umożliwiające ponowne zezwolenie na odczyt w regionach objętych denyRead — przydatne, gdy chcemy zablokować większość drzewa katalogów, ale dodać do białej listy wybrane podkatalogi.¹²⁶

Jak działają hooks?

Hooks wykonują deterministyczne polecenia powłoki w określonych punktach przepływu pracy Claude Code. W odróżnieniu od instruowania Claude do wykonywania działań, hooks gwarantują wykonanie niezależnie od zachowania modelu. Są niezbędne do egzekwowania standardów zespołowych i automatyzacji powtarzalnych zadań. Więcej informacji w sekcji Decision Frameworks, gdzie znajduje się drzewo decyzyjne „Which Hook Type?” obejmujące hooks typu command, prompt i agent.

Dlaczego hooks zamiast promptów: Powiedzenie Claude „zawsze uruchamiaj Prettier po edycji plików” czasem działa. Jednak Claude może o tym zapomnieć, przedłożyć szybkość nad jakość lub uznać, że zmiana jest „zbyt mała”. Hooks gwarantują wykonanie: każda operacja Edit lub Write uruchamia formatter, za każdym razem, bez wyjątków. W kontekście zgodności, bezpieczeństwa i standardów zespołowych podejście deterministyczne jest lepsze od probabilistycznego.⁷

Dostępne zdarzenia

Konfiguracja hooks

Hooks definiuje się w settings.json lub dedykowanym pliku hooks.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\""
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/validate-bash.sh"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/inject-context.sh"
          }
        ]
      }
    ]
  }
}

Matchery

Pole matcher określa, które narzędzia wyzwalają hook:

{"matcher": "*"}              // Match all tools
{"matcher": "Bash"}           // Match Bash only
{"matcher": "Edit|Write"}     // Match Edit or Write
{"matcher": "mcp__github"}    // Match MCP server tools
{"matcher": ""}               // Match for events without tools (like UserPromptSubmit)

Protokół wejścia/wyjścia hooks

Hooks otrzymują JSON na stdin:

{
  "tool_name": "Bash",
  "tool_input": {
    "command": "npm test",
    "description": "Run test suite"
  },
  "session_id": "abc-123"
}

Wzbogacanie zdarzeń hooks (v2.1.69+): Wszystkie zdarzenia hooks zawierają teraz pola agent_id i agent_type, gdy są wyzwalane z subagenta lub sesji --agent, a także pole worktree w poleceniach hooks paska stanu.¹¹⁷

Hooks Stop/SubagentStop (v2.1.47+) otrzymują dodatkowe pole last_assistant_message zawierające końcowy tekst odpowiedzi Claude, dzięki czemu hooks mogą sprawdzić wyjście bez parsowania plików transkrypcji:

{
  "session_id": "abc-123",
  "last_assistant_message": "I've completed the refactoring. Here's what changed..."
}

Kody wyjścia kontrolują zachowanie: - 0: Sukces — operacja jest kontynuowana. Stdout wyświetlane w trybie verbose (Ctrl+O). Dla UserPromptSubmit i SessionStart stdout jest dodawane do kontekstu. - 2: Błąd blokujący — operacja zostaje zatrzymana. Stderr staje się komunikatem błędu przekazywanym do Claude. - 1, 3, itd.: Błąd nieblokujący — operacja jest kontynuowana. Stderr wyświetlane jako ostrzeżenie w trybie verbose.

Dla zaawansowanej kontroli hooks mogą zwracać JSON:

{
  "decision": "allow",
  "message": "Command validated and modified",
  "modifications": {
    "tool_input": {
      "command": "npm test -- --coverage"
    }
  }
}

Kontrola decyzji PreToolUse (preferowany format): Hooks PreToolUse używają hookSpecificOutput do bardziej szczegółowej kontroli: trzy wyniki (allow/deny/ask) oraz możliwość modyfikacji danych wejściowych narzędzia i wstrzykiwania kontekstu:⁹⁶

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow",
    "permissionDecisionReason": "Command validated and modified",
    "updatedInput": {
      "command": "npm test -- --coverage --ci"
    },
    "additionalContext": "Note: This database has a 5-second query timeout."
  }
}

Uwaga: Pola najwyższego poziomu decision i reason są przestarzałe dla PreToolUse. Zamiast nich należy używać hookSpecificOutput.permissionDecision i hookSpecificOutput.permissionDecisionReason. Inne zdarzenia (PostToolUse, Stop, itp.) nadal używają pól najwyższego poziomu decision.⁹⁶

Asynchroniczne hooks (styczeń 2026)

Hooks mogą teraz działać w tle bez blokowania wykonania Claude Code. Wystarczy dodać async: true do konfiguracji hook:⁸⁸

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/notify-slack.sh",
            "async": true
          }
        ]
      }
    ]
  }
}

Kiedy używać asynchronicznych hooks: - Powiadomienia (Slack, e-mail, Pushover), które nie powinny spowalniać sesji - Logowanie i telemetria, które mogą działać w tle - Niekrytyczne przetwarzanie końcowe (analityka, kopie zapasowe)

Kiedy NIE używać asynchronicznych hooks: - Formatowanie (musi zakończyć się przed kolejną edycją) - Walidacja (musi blokować w przypadku niepowodzenia) - Każdy hook, który musi modyfikować dane wejściowe/wyjściowe narzędzia

Hooks oparte na promptach i agentach (v2.1.32+)

Poza hooks opartymi na poleceniach powłoki (type: "command"), Claude Code obsługuje dwa typy hooks wykorzystujące LLM, które oceniają warunki za pomocą rozumowania AI zamiast skryptów.⁹⁶

Hooks promptowe (type: "prompt") wysyłają jednoturowy prompt do szybkiego modelu Claude. Model zwraca { "ok": true } aby zezwolić lub { "ok": false, "reason": "..." } aby zablokować:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Evaluate if Claude should stop: $ARGUMENTS. Check if all requested tasks are complete and tests pass.",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

Hooks HTTP (type: "http") wysyłają dane wejściowe zdarzenia w formacie JSON jako żądanie POST na podany URL i otrzymują JSON w odpowiedzi. Można ich używać do webhooków, zewnętrznych usług powiadomień lub walidacji opartej na API (v2.1.63+):¹¹¹

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "http",
            "url": "https://api.example.com/notify",
            "headers": {
              "Authorization": "Bearer $MY_TOKEN"
            },
            "allowedEnvVars": ["MY_TOKEN"]
          }
        ]
      }
    ]
  }
}

Hooks HTTP używają tego samego formatu decyzji co hooks command (zwracają JSON z polami decision i reason). Są kierowane przez proxy sieciowe sandboxa, gdy sandboxing jest włączony. Nie są obsługiwane dla zdarzeń SessionStart/Setup.

Hooks agentowe (type: "agent") uruchamiają subagenta z dostępem do narzędzi (Read, Grep, Glob) do wieloturowej weryfikacji. Należy ich używać, gdy sprawdzenie wymaga inspekcji rzeczywistych plików lub wyników testów:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Verify all unit tests pass. Run the test suite and check results. $ARGUMENTS",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

$ARGUMENTS służy jako placeholder dla danych wejściowych hook w formacie JSON. Oba typy obsługują pola model (domyślnie szybki model) i timeout. Obsługiwane zdarzenia: PreToolUse, PostToolUse, PostToolUseFailure, PermissionRequest, UserPromptSubmit, Stop, SubagentStop, TaskCompleted. TeammateIdle nie obsługuje hooks promptowych/agentowych.

Zmienne środowiskowe hooks

Hooks mają dostęp do zmiennych środowiskowych do rozwiązywania ścieżek:⁹⁶

Utrwalanie zmiennych środowiskowych z SessionStart:

#!/bin/bash
if [ -n "$CLAUDE_ENV_FILE" ]; then
  echo 'export NODE_ENV=production' >> "$CLAUDE_ENV_FILE"
fi
exit 0

Bezpieczeństwo hooks HTTP (v2.1.51+): Hooks HTTP, które interpolują zmienne środowiskowe do nagłówków, wymagają teraz jawnej listy allowedEnvVars. Zapobiega to arbitralnej ekstrakcji zmiennych środowiskowych przez wartości nagłówków. Hooks HTTP są również kierowane przez proxy sieciowe sandboxa, gdy sandboxing jest włączony, wymuszając listę dozwolonych domen. Hooks HTTP nie są obsługiwane dla zdarzeń SessionStart/Setup.¹⁰⁵

{
  "hooks": {
    "PostToolUse": [{
      "hooks": [{
        "type": "command",
        "command": "curl -H 'Authorization: Bearer $MY_TOKEN' https://api.example.com/notify",
        "allowedEnvVars": ["MY_TOKEN"]
      }]
    }]
  }
}

Zaufanie workspace dla hooks (v2.1.51+): Polecenia hooks statusLine i fileSuggestion wymagają teraz zaakceptowania zaufania workspace przed wykonaniem w trybie interaktywnym, zamykając potencjalny wektor bezpieczeństwa.¹⁰⁵

Praktyczne przykłady hooks

Automatyczne formatowanie plików TypeScript po edycji:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.ts ]] && npx prettier --write \"$FILE_PATH\" || true'"
          }
        ]
      }
    ]
  }
}

Logowanie wszystkich poleceń bash:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command' >> ~/.claude/bash-history.log"
          }
        ]
      }
    ]
  }
}

Blokowanie dostępu do wrażliwych plików:

#!/bin/bash
# .claude/hooks/protect-files.sh
data=$(cat)
path=$(echo "$data" | jq -r '.tool_input.file_path // empty')

if [[ "$path" == *".env"* ]] || [[ "$path" == *"secrets/"* ]] || [[ "$path" == *".pem"* ]]; then
  echo "Blocked: Cannot access sensitive file $path" >&2
  exit 2  # Exit 2 = block the tool call. Exit 1 = non-blocking error (hook failure only).
fi
exit 0

Uruchamianie testów po zmianach w kodzie:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "bash -c '[[ \"$FILE_PATH\" == *.test.ts ]] || npm run test:affected'"
          }
        ]
      }
    ]
  }
}

Niestandardowy system powiadomień:

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Waiting for your input'"
          }
        ]
      }
    ]
  }
}

Wstrzykiwanie dynamicznego kontekstu do promptów:

#!/bin/bash
# .claude/hooks/inject-context.sh
# Add current git branch and recent commits to every prompt

branch=$(git branch --show-current 2>/dev/null)
commits=$(git log --oneline -3 2>/dev/null | tr '\n' ' ')

if [ -n "$branch" ]; then
  echo "[Context: Branch '$branch', Recent: $commits]"
fi
exit 0

Debugowanie hooks

Tryb debugowania umożliwia diagnozowanie problemów z hooks:

claude --debug

Tryb debugowania loguje: - Czasy wykonania hooks - Dane wejściowe/wyjściowe - Komunikaty błędów i ślady stosu - Wyniki decyzji (allow/reject/ask)

Wyświetlanie źródła hooks (v2.1.75+): Gdy hook wymaga potwierdzenia użytkownika, monit uprawnień pokazuje teraz źródło hook (settings, plugin lub skill), co ułatwia identyfikację komponentu żądającego dostępu.¹²⁴

Hooks o zasięgu komponentu (v2.1.0+)

Hooks można definiować bezpośrednio w Skills, subagentach i poleceniach slash za pomocą frontmatter. Te hooks mają zasięg ograniczony do cyklu życia komponentu i działają tylko wtedy, gdy dany komponent jest aktywny.⁴¹

Skill z wbudowanymi hooks:

---
name: secure-deployment
description: Deployment skill with security validation
hooks:
  PreToolUse:
    - matcher: Bash
      command: ".claude/hooks/validate-deploy.sh"
  PostToolUse:
    - matcher: Bash
      command: ".claude/hooks/log-deploy.sh"
  Stop:
    - command: ".claude/hooks/cleanup.sh"
      once: true  # Run only once per session
---

Obsługiwane zdarzenia: PreToolUse, PostToolUse, Stop

Opcja once (tylko w skills i poleceniach slash) zapewnia, że hook zostanie uruchomiony tylko raz na sesję, co jest przydatne do zadań czyszczenia lub finalizacji.

Strategia dla długotrwałych sesji

Dla nocnych lub nienadzorowanych sesji Claude Code warto skonfigurować hooks tak, aby utrzymywały Claude na właściwym torze bez ręcznej interwencji. Kluczowa zasada: należy używać hooks lintingu i testowania jako barierek ochronnych, które zmuszają Claude do naprawienia problemów przed kontynuacją.⁶⁴

Wzorzec „Nie zatrzymuj się, dopóki testy nie przejdą”:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint && npm run typecheck",
            "timeout": 60000
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "npm test || echo 'Tests failing - Claude should fix before stopping'"
          }
        ]
      }
    ]
  }
}

Strategia dla sesji nocnych:

1. Sprawdzenie wstępne: Hook Setup weryfikuje gotowość środowiska
2. Ciągła walidacja: Hooks PostToolUse uruchamiają testy po każdej zmianie
3. Bramka ukończenia: Hooks Stop weryfikują wszystkie kryteria akceptacji, zanim Claude zadeklaruje „gotowe”
4. Powiadomienie: Hooks Stop mogą powiadomić przez Slack/Pushover, gdy Claude zakończy pracę lub utknie

Połączenie z --dangerously-skip-permissions w kontenerze z sandboxem umożliwia w pełni autonomiczne nocne sesje. Claude będzie iterować, dopóki testy nie przejdą lub nie wyczerpie dostępnych opcji.

Czym jest MCP (Model Context Protocol)?

MCP rozszerza Claude Code o dostęp do zewnętrznych narzędzi, baz danych, API, oraz usług za pośrednictwem ustandaryzowanego protokołu. Ekosystem rozwija się dynamicznie: MCP osiągnął 100 milionów pobrań miesięcznie i ponad 3000 serwerów zindeksowanych na MCP.so (styczeń 2026), umacniając swoją pozycję jako standard branżowy łączenia AI z narzędziami i danymi.³⁵⁴ Zrozumienie MCP jest niezbędne do integracji Claude z istniejącym zestawem narzędzi.

Dlaczego MCP ma znaczenie dla programistów: Bez MCP, Claude Code może jedynie odczytywać pliki i uruchamiać polecenia bash. Z MCP, Claude może odpytywać produkcyjną bazę danych, tworzyć zgłoszenia w Jira, przeglądać pull requesty na GitHub, sprawdzać błędy w Sentry i wchodzić w interakcję z dowolnym API używanym przez zespół — wszystko za pomocą zapytań w języku naturalnym. Protokół standaryzuje sposób, w jaki narzędzia AI łączą się z zewnętrznymi usługami, zapobiegając uzależnieniu od dostawcy. Sekcja Ramy decyzyjne zawiera wskazówki, kiedy stosować MCP zamiast innych mechanizmów rozszerzeń.

Obsługa zdalnych serwerów MCP (czerwiec 2025)

Claude Code obsługuje teraz zdalne serwery MCP z natywnym uwierzytelnianiem OAuth.²⁸ Można łączyć się z narzędziami i źródłami danych bez konieczności zarządzania lokalnymi serwerami. Wystarczy jednorazowe uwierzytelnienie, a Claude Code automatycznie odświeża tokeny.

# Connect to remote MCP server with OAuth
claude mcp add --transport http linear https://mcp.linear.app/sse
# Browser opens for OAuth flow, tokens stored securely

Konektory MCP z claude.ai (v2.1.46+)

Claude Code może teraz korzystać z konektorów MCP skonfigurowanych na koncie claude.ai. Łączy to środowisko webowe z CLI: serwery MCP skonfigurowane przez interfejs claude.ai są automatycznie dostępne w Claude Code bez konieczności ich ponownej konfiguracji lokalnie.¹⁰²

Wyłączanie: Aby zapobiec ładowaniu serwerów MCP z claude.ai, należy ustawić ENABLE_CLAUDEAI_MCP_SERVERS=false w zmiennych środowiskowych lub w bloku env pliku settings.json.¹¹¹

Wyszukiwanie narzędzi MCP (v2.1.7+)

W miarę rozwoju serwerów MCP (niektóre udostępniają ponad 50 narzędzi), opisy narzędzi zaczęły nadmiernie obciążać kontekst. Wyszukiwanie narzędzi MCP rozwiązuje ten problem, dynamicznie ładując opisy narzędzi tylko wtedy, gdy są potrzebne — jest to forma leniwego ładowania dla narzędzi AI.⁵⁴

Wpływ na wydajność: Wewnętrzne testy porównawcze wykazują znaczną poprawę dokładności: - Opus 4: 49% → 74% w ewaluacjach MCP - Opus 4.5: 79,5% → 88,1% w ewaluacjach MCP - Redukcja narzutu tokenów: 85%

Jak to działa: Gdy opisy narzędzi MCP przekraczają 10% okna kontekstowego (domyślny próg), Claude Code odkłada ładowanie pełnych opisów do momentu, gdy będą faktycznie potrzebne. Claude widzi nazwy narzędzi, ale pobiera opisy na żądanie.

Konfiguracja:

{
  "mcpToolSearchAutoEnable": "auto:15"  // Enable when tools exceed 15% of context
}

Wartości: - true — zawsze włączone wyszukiwanie narzędzi - false — zawsze wyłączone (ładowanie wszystkich opisów narzędzi z góry) - auto:N — włączenie, gdy narzędzia przekraczają N% kontekstu (0-100)

Wskazówka ekspercka: Po włączeniu wyszukiwania narzędzi można podłączyć znacznie więcej serwerów MCP bez obaw o limity kontekstu. Redukcja kontekstu o 95% sprawia, że serwery, które wcześniej rywalizowały o kontekst, teraz współistnieją bez konfliktów.

Pozyskiwanie danych MCP (v2.1.76+)

Serwery MCP mogą teraz żądać od użytkownika ustrukturyzowanych danych w trakcie realizacji zadania za pomocą interaktywnych okien dialogowych.¹²⁵ Gdy serwer MCP potrzebuje dodatkowych informacji (np. wyboru gałęzi, podania nazwy projektu, potwierdzenia akcji), wysyła żądanie, które Claude Code renderuje jako pola formularza lub adres URL w przeglądarce.

Integracja z hooks: Dwa nowe zdarzenia hooks — Elicitation (przed wyświetleniem dialogu) i ElicitationResult (po odpowiedzi użytkownika) — umożliwiają programowe przechwytywanie, walidację lub nadpisywanie odpowiedzi. Pozwala to na tworzenie przepływów pracy w przedsiębiorstwach, w których monity serwerów MCP są wstępnie wypełniane lub ograniczane przez politykę.

Interaktywny kreator konfiguracji MCP

Uruchomienie claude mcp add bez argumentów uruchamia interfejs krok po kroku do dodawania serwerów MCP. Kreator przeprowadza przez wybór typu transportu, uwierzytelnianie i konfigurację.¹⁵

Typy transportu

HTTP (zalecany dla serwerów zdalnych):

claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# With authentication
claude mcp add --transport http api https://api.example.com/mcp \
  --header "Authorization: Bearer $API_TOKEN"

SSE (przestarzały, ale funkcjonalny):

claude mcp add --transport sse asana https://mcp.asana.com/sse \
  --header "X-API-Key: your-key"

Stdio (serwery lokalne):

# PostgreSQL
claude mcp add --transport stdio postgres \
  --env "DATABASE_URL=postgresql://user:pass@localhost/db" \
  -- npx -y @anthropic-ai/mcp-server-postgres

# Custom server
claude mcp add --transport stdio custom -- python /path/to/server.py --port 8000

W systemie Windows wymagana jest nakładka cmd dla stdio:

claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package

Zarządzanie zakresami

Serwery MCP istnieją w trzech zakresach z jasnym priorytetem (lokalny nadpisuje projektowy, projektowy nadpisuje użytkownika):

Określanie zakresu podczas instalacji:

claude mcp add --scope project --transport http github https://...
claude mcp add --scope user --transport stdio personal-tool -- ./my-tool

Format pliku konfiguracyjnego

Plik .mcp.json definiuje serwery na poziomie projektu:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "database": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${SENTRY_API_KEY}"
      }
    },
    "internal-api": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "X-API-Key": "${INTERNAL_API_KEY}"
      }
    }
  }
}

Zmienne środowiskowe są rozwijane przy użyciu składni ${VAR} z opcjonalnymi wartościami domyślnymi: ${VAR:-default}.

Polecenia zarządzania MCP

claude mcp list                      # View all configured servers
claude mcp get github                # Get specific server details
claude mcp remove github             # Remove a server
claude mcp reset-project-choices     # Reset project-scoped approvals
claude mcp add-from-claude-desktop   # Import from Claude Desktop
claude mcp add-json weather '{"type":"http","url":"..."}'  # Add from JSON

# Within Claude Code REPL
> /mcp                               # Interactive MCP management

Uwierzytelnianie OAuth

Dla serwerów wymagających OAuth:

> /mcp
# Follow browser-based OAuth flow
# Tokens stored securely and auto-refreshed
# Use "Clear authentication" to revoke access

Korzystanie z zasobów i promptów MCP

Odwoływanie się do zasobów:

@github:issue://123
@postgres:schema://users
@docs:file://api/authentication

Prompty MCP jako polecenia slash:

/mcp__github__list_prs
/mcp__github__pr_review 456
/mcp__jira__create_issue "Bug title" high

Limity wyjściowe

Claude Code ogranicza dane wyjściowe MCP, aby zapobiec przepełnieniu kontekstu: - Próg ostrzegawczy: 10 000 tokenów - Domyślne maksimum: 25 000 tokenów

W razie potrzeby można zwiększyć limit:

export MAX_MCP_OUTPUT_TOKENS=50000

Popularne serwery MCP

Praktyczne wzorce MCP

Przepływ pracy z GitHub:

> Review PR #456
> List all open issues assigned to me
> Create a bug issue for the authentication failure we found

Zapytania do bazy danych:

> What's our total revenue this quarter?
> Show the schema for the users table
> Find customers with no purchases in 90 days

Monitorowanie błędów:

> What errors occurred in production today?
> Show the stack trace for error ABC123
> Which deployment introduced these errors?

Konfiguracja MCP dla przedsiębiorstw

Administratorzy systemowi mogą wymuszać polityki MCP za pomocą pliku managed-mcp.json:

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "sentry" },
    { "serverCommand": ["npx", "-y", "@approved/server"] }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" }
  ]
}

Lokalizacja: - macOS: /Library/Application Support/ClaudeCode/managed-mcp.json - Linux: /etc/claude-code/managed-mcp.json - Windows: C:\ProgramData\ClaudeCode\managed-mcp.json

Lista odmów ma bezwzględny priorytet. Polecenia muszą dokładnie odpowiadać, łącznie z kolejnością argumentów.

Aplikacje MCP (styczeń 2026)

Anthropic uruchomił Aplikacje MCP — rozszerzenie Model Context Protocol umożliwiające tworzenie interaktywnych interfejsów narzędzi bezpośrednio w środowisku Claude.⁷⁸ Aplikacje MCP pozwalają użytkownikom przeglądać, edytować i wchodzić w interakcję z treściami z zewnętrznych usług bez opuszczania Claude, w tym z Asana, Box, Canva, Figma, Hex, monday.com i Slack. Każdy serwer MCP może dostarczyć interaktywny interfejs renderowany wewnątrz Claude. Choć Aplikacje MCP pojawiają się obecnie w interfejsie webowym claude.ai, bazowe rozszerzenia protokołu MCP mają znaczenie dla ekosystemu MCP w Claude Code, w miarę jak serwery adoptują nowe interaktywne możliwości.

Platforma API: Narzędzie wykonywania kodu v2 (styczeń 2026)

Anthropic uruchomił v2 narzędzia wykonywania kodu w publicznej becie, zastępując oryginalne środowisko sandbox ograniczone do Python wykonywaniem poleceń Bash i bezpośrednią manipulacją plików.⁷⁹ Kluczowe zmiany: - Wykonywanie poleceń Bash (nie tylko Python) w kontenerach sandbox - Pisanie i uruchamianie kodu w dowolnym języku - Programowe wywoływanie narzędzi (również w publicznej becie): Claude może wywoływać narzędzia z poziomu wykonywania kodu, zmniejszając opóźnienia i zużycie tokenów w przepływach pracy wykorzystujących wiele narzędzi

Narzędzie v2 dotyczy głównie użytkowników API, ale wyznacza kierunek rozwoju możliwości wykonywania kodu w chmurze dla Claude Code.

Czym są subagenty?

Subagenty to wyspecjalizowane instancje Claude, które samodzielnie obsługują złożone zadania. Są jedną z najpotężniejszych funkcji Claude Code i jedną z najmniej zrozumianych. Opanowanie subagentów znacząco rozszerza możliwości użytkownika. Zobacz Ramy decyzyjne, aby uzyskać wskazówki dotyczące wyboru między Agent Teams, subagentami a sesjami równoległymi.

Dlaczego subagenty istnieją: Główna konwersacja Claude Code ma pojedyncze okno kontekstu. Wszystko, co jest omawiane, każdy plik odczytywany przez Claude, każde wyjście narzędzia — to wszystko zużywa ten kontekst. W długich sesjach kontekst się zapełnia, Claude traci ślad wcześniejszych decyzji, a wydajność spada. Subagenty rozwiązują ten problem poprzez izolację pracy: wyniki eksploracji nie obciążają głównej konwersacji, wraca tylko podsumowanie. Claude może również uruchamiać do 10 subagentów równolegle, umożliwiając współbieżną pracę, która byłaby niemożliwa sekwencyjnie.²

Jak działają subagenty

Gdy Claude napotka zadanie wymagające skupionej uwagi (głęboka eksploracja, wieloetapowa analiza, wyspecjalizowana praca), może utworzyć subagenta. Subagent:

1. Zaczyna z czystym kontekstem (bez zanieczyszczeń z głównej konwersacji)
2. Ma dostęp do określonych narzędzi
3. Działa z określonym modelem (często tańszym/szybszym)
4. Zwraca wyniki do głównej konwersacji

Taka architektura zapobiega przepełnieniu kontekstu, jednocześnie umożliwiając złożone przepływy pracy.

Wbudowane typy subagentów

Explore (szybki, tylko do odczytu): - Model: Haiku (ultraszybki) - Tryb: Wyłącznie do odczytu - Narzędzia: Glob, Grep, Read oraz bezpieczne polecenia bash (ls, git status, git log, git diff, find, cat, head, tail) - Poziomy dokładności: Quick, Medium, Very thorough - Zastosowanie: Eksploracja bazy kodu, wyszukiwanie plików, rozumienie struktury

General-purpose: - Model: Dziedziczony z głównej konwersacji - Tryb: Pełny odczyt/zapis - Narzędzia: Wszystkie dostępne narzędzia - Zastosowanie: Złożone zadania badawcze i modyfikacyjne

Plan: - Model: Dziedziczony z głównej konwersacji (lub Opus z opusplan) - Tryb: Tylko do odczytu - Narzędzia: Read, Glob, Grep, Bash - Zastosowanie: Planowanie złożonych implementacji przed wykonaniem

Uruchamianie subagentów

Claude automatycznie deleguje zadania do subagentów na podstawie ich typu. Można również jawnie o to poprosić:

> Use the explore agent to find all authentication-related files

> Have a subagent analyze the database schema thoroughly

> Spawn an agent to research how error handling works in this codebase

Wskazówka eksperta: W przypadku złożonych zadań warto jawnie zażądać delegacji do subagenta. „Use an explore agent to find…” zapobiega rozrostowi kontekstu w głównej konwersacji.

Tworzenie własnych subagentów

Subagenty definiuje się w .claude/agents/ (projekt) lub ~/.claude/agents/ (osobiste):

---
name: security-reviewer
description: Expert security code reviewer. Use PROACTIVELY after any code changes to authentication, authorization, or data handling.
tools: Read, Grep, Glob, Bash
model: opus
permissionMode: plan
---

You are a senior security engineer reviewing code for vulnerabilities.

When invoked:
1. Identify the files that were recently changed
2. Analyze for OWASP Top 10 vulnerabilities
3. Check for secrets, hardcoded credentials, SQL injection
4. Report findings with severity levels and remediation steps

Focus on actionable security findings, not style issues.

Pola konfiguracyjne:

Ograniczanie typów subagentów (v2.1.33+, zmiana nazwy v2.1.63): Pole tools obsługuje składnię Agent(agent_type) do ograniczania typów subagentów, które agent może tworzyć. Na przykład tools: Read, Grep, Agent(Explore) pozwala agentowi bezpośrednio używać Read i Grep, ale delegować tylko do subagentów typu Explore. Ograniczenie zapobiega nadmiernej delegacji w agentach z ograniczeniami. Uwaga: W v2.1.63 narzędzie Task zostało przemianowane na Agent. Istniejące odwołania Task(...) w ustawieniach i definicjach agentów nadal działają jako aliasy zapewniające kompatybilność wsteczną.¹¹³

Subagenty definiowane z CLI (v2.1.32+)

Subagenty można definiować jako JSON przy uruchomieniu w celu szybkiego testowania lub automatyzacji. Istnieją one tylko na czas sesji i nie są zapisywane na dysku:⁹⁶

claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality and security.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  }
}'

Flaga --agents przyjmuje JSON z tymi samymi polami frontmatter co subagenty zdefiniowane w plikach: description, prompt, tools, disallowedTools, model, permissionMode, mcpServers, hooks, maxTurns, skills i memory.

Zarządzanie subagentami

> /agents                    # Interaktywne zarządzanie
> /agents create             # Tworzenie nowego subagenta
> /agents edit               # Modyfikacja istniejącego
> /agents delete             # Usuwanie subagenta
> /agents list               # Wyświetlanie wszystkich

Listowanie z CLI (v2.1.50+): Wyświetlanie wszystkich skonfigurowanych agentów z linii poleceń bez uruchamiania sesji interaktywnej:

claude agents                # Shows agents grouped by source (built-in, user, project, plugin)

Zdalne sterowanie (v2.1.51+): Podpolecenie claude remote-control udostępnia lokalne środowisko dla zewnętrznych buildów, umożliwiając wszystkim użytkownikom zdalny dostęp do możliwości lokalnego środowiska:¹⁰⁵

claude remote-control                      # Start serving local environment
claude remote-control --name "My Project"  # Custom session title visible in claude.ai/code (v2.1.69+)[^117]

Uruchamianie agentów w tle

W przypadku długotrwałych zadań:

> Run a thorough security review in the background

> /agents  # Check status of running agents

Wyniki można pobrać później, używając identyfikatora agenta.

Zaawansowane wzorce

Łańcuchowe subagenty:

> First use the code-analyzer subagent to find performance issues, then use the optimizer subagent to fix them

Równoległa eksploracja:

> Have three explore agents search in parallel:
> 1. Authentication code
> 2. Database models
> 3. API routes

Wznawialne agenty: Agenty można wznawiać za pomocą ich identyfikatora, aby kontynuować wcześniejszą pracę:

> Resume agent abc123 and continue the analysis

Asynchroniczne subagenty (grudzień 2025)

Asynchroniczne subagenty umożliwiają wielozadaniowość i równoległe wykonywanie w projektach na dużą skalę:

> Run security review in the background while I continue frontend work
> /tasks                    # Check status of running agents

Asynchroniczne agenty zwracają wyniki przez zunifikowane TaskOutputTool, umożliwiając wydajne przepływy pracy w stylu potokowym.

Odporność na odmowę uprawnień (v2.1.0+)

Począwszy od v2.1.0, subagenty kontynuują pracę po odmowach uprawnień zamiast całkowicie się zatrzymywać. Gdy subagent napotka barierę uprawnień, automatycznie próbuje alternatywnych podejść. Ta zmiana sprawia, że autonomiczne przepływy pracy są bardziej odporne i zmniejsza potrzebę interwencji człowieka.⁴⁷

Agent Teams (luty 2026, Research Preview)

Agent Teams koordynują wiele instancji Claude Code pracujących razem. Jedna sesja pełni rolę lidera zespołu, tworząc współpracowników, którzy pracują niezależnie we własnych oknach kontekstu, komunikując się bezpośrednio ze sobą za pośrednictwem wspólnej skrzynki pocztowej i listy zadań.⁸⁶⁹¹

W przeciwieństwie do subagentów (które działają w ramach pojedynczej sesji i raportują tylko do wywołującego), współpracownicy to pełne niezależne sesje, które mogą wzajemnie wysyłać wiadomości, kwestionować wzajemne ustalenia i samodzielnie się koordynować.

Włączanie:

// settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Lub przez zmienną środowiskową: export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Architektura:

Tryby wyświetlania:

Konfiguracja w ustawieniach: "teammateMode": "in-process" lub "tmux". Lub per sesja: claude --teammate-mode in-process.

Kluczowe skróty: - Shift+Down: Przełączanie między współpracownikami (tryb in-process; po ostatnim wraca do lidera) - Shift+Tab: Włączenie trybu delegowania (ogranicza lidera tylko do koordynacji, bez zmian w kodzie) - Ctrl+T: Przełączanie wspólnej listy zadań - Enter na współpracowniku: Podgląd jego sesji; Escape do przerwania jego tury

Kiedy używać Agent Teams zamiast subagentów:

Najlepsze zastosowania: - Badania i przeglądy (wiele perspektyw jednocześnie) - Nowe moduły/funkcje (każdy współpracownik odpowiada za oddzielne elementy) - Debugowanie z konkurencyjnymi hipotezami (testowanie różnych teorii równolegle) - Koordynacja międzywarstwowa (frontend, backend, testy — każdy zarządzany przez innego współpracownika)

Zatwierdzanie planów dla współpracowników: W przypadku złożonych lub ryzykownych zadań można wymagać, aby współpracownicy planowali przed implementacją. Współpracownik pracuje w trybie planu tylko do odczytu, dopóki lider nie przejrzy i nie zatwierdzi jego podejścia:

Spawn an architect teammate to refactor the authentication module.
Require plan approval before they make any changes.

Lider podejmuje decyzje o zatwierdzeniu autonomicznie. Jego ocenę można kształtować za pomocą kryteriów: „only approve plans that include test coverage” lub „reject plans that modify the database schema.”

Przykładowe prompty:

Create an agent team to review PR #142. Spawn three reviewers:
- One focused on security implications
- One checking performance impact
- One validating test coverage

Spawn a team with 4 teammates to refactor these modules in parallel.
Use Sonnet for each teammate.

Przechowywanie: Konfiguracje zespołów znajdują się w ~/.claude/teams/{team-name}/config.json (tablica members z name, agent ID, agent type). Listy zadań w ~/.claude/tasks/{team-name}/. Zadania obsługują zależności: zablokowane zadania odblokowują się automatycznie po ukończeniu ich zależności.⁹¹

Integracja z hooks: Hooki TeammateIdle (kod wyjścia 2, aby wysłać feedback i utrzymać współpracownika w pracy) oraz TaskCompleted (kod wyjścia 2, aby zapobiec zakończeniu) pozwalają egzekwować bramki jakościowe dla współpracowników.

Ograniczenia (eksperymentalne): - Brak wznawiania sesji dla współpracowników in-process (/resume ich nie przywróci) - Jeden zespół na sesję; brak zagnieżdżonych zespołów - Współpracownicy nie mogą tworzyć własnych zespołów - Panele dzielone wymagają tmux lub iTerm2 (brak obsługi w terminalu VS Code, Windows Terminal ani Ghostty) - Wszyscy współpracownicy startują z trybem uprawnień lidera - Intensywne zużycie tokenów: każdy współpracownik to oddzielna instancja Claude

Agent Skills (grudzień 2025)

Agent Skills to zorganizowane foldery instrukcji, skryptów i zasobów, które agenty odkrywają i ładują dynamicznie.³¹ Zapewniają komponowalne, przenośne kompetencje domenowe:

.claude/skills/
├── security-review/
│   ├── skill.md           # Instructions and prompts
│   ├── checklist.md       # Security checklist
│   └── common-vulns.sh    # Detection scripts
└── performance-audit/
    ├── skill.md
    └── profiling-guide.md

Skills różnią się od poleceń: polecenia są wywoływane jawnie, podczas gdy skills aktywują się automatycznie na podstawie kontekstu zadania. Claude Agent SDK (przemianowany z Claude Code SDK) zapewnia framework do budowania własnych agentów z obsługą skills.³²

Czym jest tryb rozszerzonego myślenia?

Rozszerzone myślenie daje Claude więcej czasu na przemyślenie złożonych problemów przed udzieleniem odpowiedzi. Jest szczególnie wartościowe przy decyzjach architektonicznych, debugowaniu trudnych problemów oraz zadaniach wymagających starannej analizy.

Aktualny stan (marzec 2026)

Rozszerzone myślenie jest teraz domyślnie włączone z budżetem 31 999 tokenów.⁷⁰ Anthropic wprowadził tę zmianę, ponieważ rozszerzone myślenie znacząco poprawia wydajność przy złożonych zadaniach planowania i rozumowania.

Poziomy wysiłku (v2.1.68+, uproszczone w v2.1.72): Opus 4.6 domyślnie używa średniego poziomu wysiłku dla subskrybentów Max i Team — optymalnego kompromisu między szybkością a dokładnością. Poziom wysiłku wyświetla się w logo i animacji ładowania z uproszczonymi symbolami: ○ (niski), ◐ (średni), ● (wysoki).¹²¹ Słowo kluczowe „ultrathink” zostało ponownie wprowadzone w celu aktywacji trybu wysokiego wysiłku. Inne wyzwalacze w języku naturalnym („think”, „think hard”, „think harder”) pozostają wycofane — zamiast nich należy użyć MAX_THINKING_TOKENS lub /config.⁷⁰¹¹⁶

Uwaga: Opus 4 i Opus 4.1 zostały usunięte z Claude Code w pierwszorzędnym API (v2.1.68). Użytkownicy, którzy mieli te modele przypięte, zostali automatycznie przeniesieni na Opus 4.6.¹¹⁶

Obsługiwane modele

• Claude Opus 4.6 (obsługuje również adaptacyjne myślenie, które automatycznie określa głębokość rozumowania)
• Claude Sonnet 4.6 (obsługuje również adaptacyjne myślenie)
• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Kontrolowanie rozszerzonego myślenia

Szybkie przełączanie podczas sesji:

Press Alt+T to toggle thinking on/off

Uwaga: Anthropic zmienił przełącznik myślenia z Tab na Alt+T, aby uniknąć przypadkowych aktywacji.³⁹

Przez /config: Należy przejść do /config → Extended Thinking, aby włączyć/wyłączyć lub dostosować budżet.

Zmienna środowiskowa (trwała):

# Set custom budget (default is 31,999)
export MAX_THINKING_TOKENS=8000
claude

# Double the default for complex tasks
export MAX_THINKING_TOKENS=63999
claude

Wyłączenie w celu oszczędności: Przy prostszych zadaniach, gdzie głębokie rozumowanie nie jest potrzebne, można zmniejszyć koszty, wyłączając myślenie w /config lub obniżając budżet:

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Budżety tokenów myślenia

Kwestia kosztów: Anthropic nalicza opłaty za tokeny myślenia jako tokeny wyjściowe. Domyślny budżet 31 999 sprawdza się przy większości zadań, ale przy prostych operacjach można zaoszczędzić, zmniejszając budżet lub całkowicie wyłączając myślenie.

Jak to działa

Gdy myślenie jest włączone, Claude przeprowadza wewnętrzne rozumowanie, które wpływa na odpowiedź, ale nie pojawia się w wynikach. Claude Code szyfruje myślenie i zwraca je w polu signature w celu weryfikacji.

W wieloturowych konwersacjach z użyciem narzędzi bloki myślenia muszą być przekazywane z powrotem do API, aby zachować ciągłość rozumowania. Claude Code obsługuje to automatycznie.

Kiedy rozważyć wyłączenie lub zmniejszenie budżetu

Rozszerzone myślenie jest teraz ustawieniem domyślnym, ale warto rozważyć zmniejszenie budżetu lub wyłączenie przy: - Prostych edycjach plików - Rutynowym refaktoryzowaniu - Szybkich pytaniach - Formatowaniu kodu - Operacjach o dużym wolumenie, gdzie koszty się kumulują

Zachowanie pamięci podręcznej

Claude Code zachowuje buforowanie promptu systemowego przy zmianie parametrów myślenia. Zmiana budżetu myślenia lub statusu włączenia między turami unieważnia buforowanie wiadomości.

Style wyjścia

Style wyjścia pozwalają dostosować sposób, w jaki Claude prezentuje informacje, co jest przydatne do nauki, dokumentacji lub specyficznych preferencji zespołu.¹⁹

Wbudowane style

Ustawianie stylu wyjścia

> /output-style Explanatory
> /output-style Learning

Lub przez ustawienia:

{
  "outputStyle": "Explanatory"
}

Niestandardowe style wyjścia

Można je tworzyć w .claude/styles/:

# my-style

## Instructions
- Always explain the WHY behind each decision
- Include relevant documentation links
- Format code examples with comments
- End with a "What to do next" section

## Format
Use markdown headers for organization.
Keep explanations under 200 words per section.

Wywołanie za pomocą /output-style my-style.

Wycofanie (v2.1.73+): /output-style jest wycofany. Zamiast tego należy używać /config do zarządzania stylami wyjścia.¹²²

Polecenia slash

Polecenia slash zapewniają szybki dostęp do funkcji Claude Code i umożliwiają tworzenie niestandardowych przepływów pracy. Są szybsze niż wpisywanie pełnych promptów dla typowych operacji.

Wbudowane polecenia — kompletna lista

Tworzenie niestandardowych poleceń

Polecenia wielokrotnego użytku można tworzyć w .claude/commands/ (projektowe) lub ~/.claude/commands/ (osobiste):

---
description: Security-focused code review
allowed-tools: Read, Grep, Glob
model: claude-sonnet-4-5
---

Review this code for security vulnerabilities:

1. Injection attacks (SQL, command, XSS)
2. Authentication and authorization flaws
3. Sensitive data exposure
4. Insecure dependencies

Focus on actionable findings with specific line references.

Należy zapisać jako .claude/commands/security-review.md i wywołać poleceniem /security-review.

Opcje frontmatter poleceń

---
description: Brief description for /help
allowed-tools: Read, Edit, Bash(npm:*)
model: opus
argument-hint: [arg1] [arg2]
disable-model-invocation: false
---

Interpolacja argumentów

Wszystkie argumenty jako pojedynczy ciąg:

---
description: Fix GitHub issue
argument-hint: [issue-number]
---

Fix GitHub issue #$ARGUMENTS following our coding standards.

Użycie: /fix-issue 123

Argumenty numerowane:

---
description: Create component
argument-hint: [name] [type]
---

Create a new $2 component named $1 in src/components/.

Użycie: /create-component Button functional

Wbudowane wykonywanie Bash

Polecenia bash można wykonywać bezpośrednio w promptach poleceń:

---
description: Git status summary
allowed-tools: Bash(git:*)
---

Current branch: !`git branch --show-current`
Recent commits: !`git log --oneline -5`
Changed files: !`git status --short`

Summarize the current state of this repository.

Odwołania do plików

Zawartość plików można dołączać do poleceń:

---
description: Compare implementations
---

Compare these files:
@src/v1/handler.ts
@src/v2/handler.ts

Which implementation is more maintainable?

Przestrzenie nazw poleceń

Polecenia można organizować w podkatalogach:

.claude/commands/
├── backend/
│   ├── test.md
│   └── deploy.md
├── frontend/
│   ├── test.md
│   └── build.md
└── review.md

Polecenia o tej samej nazwie wyświetlają swoją przestrzeń nazw w pomocy: /test (project:backend) vs /test (project:frontend).

Jak działają skills?

Skills reprezentują fundamentalnie inne podejście do rozszerzania Claude Code. W przeciwieństwie do poleceń slash, które wywołuje się jawnie, skills są wywoływane przez model — Claude automatycznie je odkrywa i wykorzystuje w zależności od kontekstu. Zapisuje się w nich wiedzę domenową, a Claude czerpie z niej zawsze, gdy sytuacja tego wymaga, bez konieczności pamiętania o ich wywołaniu.

Dlaczego skills zmieniają wszystko: Rozważmy wiedzę domenową: zasady przetwarzania płatności, wymagania zgodności, wzorce architektoniczne, które zespół doskonalił przez lata. Bez skills trzeba albo wyjaśniać ten kontekst w każdej sesji, albo liczyć na to, że Claude wywnioskuje go z komentarzy w kodzie. Dzięki skills zapisuje się go raz. Claude odczytuje definicję skill i automatycznie stosuje tę wiedzę, kiedy jest to istotne. Młodsi programiści otrzymują wskazówki na poziomie seniora bez pytania. Wzorce bezpieczeństwa są egzekwowane bez konieczności pamiętania o ich wywołaniu.

To rozróżnienie ma znaczenie. Polecenie slash to skrót, o którym trzeba pamiętać. Skill to wiedza, którą Claude zawsze ma do dyspozycji. Gdy utworzy się skill przeglądu bezpieczeństwa z konkretnymi wzorcami podatności i wymaganiami zgodności zespołu, Claude stosuje tę wiedzę za każdym razem, gdy napotka odpowiedni kod — zarówno podczas przeglądów PR, refaktoryzacji, jak i każdego zadania, w którym bezpieczeństwo ma znaczenie. Nie trzeba wywoływać /security-review; Claude rozpoznaje kontekst i automatycznie stosuje skill.

Skills a polecenia a subagents

Zrozumienie, kiedy używać każdego mechanizmu rozszerzania, zapobiega duplikacji i maksymalizuje skuteczność:

Polecenia slash stosuje się, gdy potrzebna jest jawna kontrola: /deploy, /test, /review PR 456. Użytkownik decyduje, kiedy je uruchomić.

Skills stosuje się, gdy wiedza ma aktywować się automatycznie: wzorce bezpieczeństwa, egzekwowanie stylu kodu, wiedza domenowa. Claude decyduje, kiedy je zastosować.

Subagents stosuje się, gdy zadania wymagają izolacji: eksploracja w tle, analiza równoległa, specjalistyczne wnioskowanie, które nie powinno zaśmiecać głównej konwersacji.

Struktura i lokalizacja skills

Skills znajdują się w dedykowanych katalogach zawierających wymagany plik SKILL.md oraz opcjonalne zasoby pomocnicze:

Skills osobiste (dostępne we wszystkich projektach):

~/.claude/skills/
├── code-reviewer/
│   ├── SKILL.md
│   ├── SECURITY_PATTERNS.md
│   └── PERFORMANCE_CHECKLIST.md
├── sql-analyst/
│   ├── SKILL.md
│   └── QUERY_PATTERNS.md
└── api-designer/
    └── SKILL.md

Skills projektowe (współdzielone z zespołem przez git):

.claude/skills/
├── domain-expert/
│   ├── SKILL.md
│   ├── BUSINESS_RULES.md
│   └── DATA_MODELS.md
└── deployment/
    ├── SKILL.md
    └── RUNBOOKS.md

Skills projektowe są commitowane do kontroli wersji. Gdy współpracownicy pobierają zmiany, automatycznie otrzymują skills — bez instalacji, bez konfiguracji. Automatyczna dystrybucja standaryzuje wiedzę w całym zespole.

Format SKILL.md

Każdy skill wymaga pliku SKILL.md z YAML frontmatter:

---
name: code-reviewer
description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review or audit code.
allowed-tools: Read, Grep, Glob
---

# Code Review Expertise

## Security Analysis

When reviewing code, check for:

### Input Validation
- All user input sanitized before use
- Parameterized queries for database operations
- Output encoding for rendered content

### Authentication & Authorization
- Session tokens properly validated
- Permission checks before sensitive operations
- No hardcoded credentials or API keys

### Data Exposure
- Sensitive data not logged
- PII properly masked in error messages
- API responses don't leak internal details

## Performance Patterns

### Database
- N+1 query detection
- Missing indexes on filtered columns
- Unbounded result sets

### Memory
- Large object lifecycle management
- Stream processing for big files
- Connection pool exhaustion risks

## Review Output Format

For each finding:
- **File**: path/to/file.ts:123
- **Severity**: Critical | High | Medium | Low
- **Category**: Security | Performance | Maintainability
- **Issue**: Clear description of the problem
- **Recommendation**: Specific fix with code example
- **Rationale**: Why this matters

See [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) for detailed vulnerability patterns.
See [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) for optimization guidelines.

Dokumentacja frontmatter

Podstawienia zmiennych (v2.1.9+): Skills mogą uzyskiwać dostęp do kontekstu sesji za pomocą podstawienia ${CLAUDE_SESSION_ID}. Przydatne do logowania, śledzenia lub generowania wyników specyficznych dla sesji.⁵¹

Pole description jest kluczowe. Claude odkrywa skills, dopasowując zapytania do opisów skills. Niejasny opis oznacza, że Claude nie rozpozna, kiedy użyć skill. Precyzyjny opis z jasnymi warunkami wyzwalania zapewnia niezawodną aktywację.

Słaby opis:

description: Helps with code