TL;DR: Claude Code to agentowy CLI, który czyta bazę kodu, wykonuje polecenia i modyfikuje pliki poprzez wielowarstwowy system uprawnień, hooks, integracji MCP oraz subagentów. Opanowanie pięciu głównych systemów (konfiguracja, uprawnienia, hooks, MCP i subagenty) odblokowuje produktywność o rząd wielkości wyższą. Można 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 jedyną zmienną jest jakość. Hooks (nie prompty) należy stosować do wszystkiego, co musi się wykonać za każdym razem.

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

Różnica między przypadkowym a efektywnym korzystaniem z Claude Code sprowadza się do pięciu głównych systemów. Opanowanie ich sprawia, że Claude Code staje się mnożnikiem produktywności:

1. Hierarchia konfiguracji: steruje zachowaniem
2. System uprawnień: kontroluje dostęp do operacji
3. System hooks: umożliwia deterministyczną automatyzację
4. Protokół MCP: rozszerza możliwości
5. System subagentów: obsługuje złożone, wieloetapowe zadania

Kluczowe wnioski

• Pięć systemów decyduje o efektywności: hierarchia konfiguracji, uprawnienia, hooks, MCP i subagenty kontrolują wszystko — od zachowania po automatyzację.
• Delegowanie pracy do warstwy delegacji: subagenty zapobiegają rozdęciu kontekstu, izolując eksplorację w czystych oknach kontekstowych i zwracając jedynie podsumowania.
• Hooks gwarantują wykonanie; prompty — nie: hooks należy stosować do lintowania, formatowania i kontroli bezpieczeństwa, które muszą się uruchomić za każdym razem, niezależnie od zachowania modelu.
• Warstwowość modeli oszczędza koszty bez poświęcania jakości: eksplorację subagentów można kierować do tańszych modeli, rezerwując Opus dla rzeczywistego rozumowania architektonicznego — lub ustandaryzować na Opus, jeśli jedyną zmienną jest jakość.
• MCP łączy Claude z narzędziami w ekosystemie: bazy danych, GitHub, Sentry i ponad 3000 integracji rozszerzają Claude poza czytanie plików i polecenia bash.

Spędziłem miesiące, testując Claude Code do granic możliwości na produkcyjnych bazach kodu, pipeline’ach CI/CD i wdrożeniach korporacyjnych. Ten przewodnik destyluje to doświadczenie w kompletną referencję, której istnienia życzyłbym sobie na początku. Każda funkcja zawiera rzeczywistą składnię, prawdziwe przykłady konfiguracji oraz przypadki brzegowe, na które natykają się nawet doświadczeni użytkownicy.

Jak korzystać z tego przewodnika

To referencja licząca ponad 5000 linii — nie trzeba jej czytać od deski do deski. Najlepiej zacząć od poziomu odpowiadającego własnemu doświadczeniu:

Do wyszukiwania konkretnych flag, poleceń lub kluczy konfiguracyjnych można użyć skrótu Ctrl+F / Cmd+F w przeglądarce. Karta szybkiej referencji na końcu zawiera skanowalne podsumowanie wszystkich głównych poleceń.

Jak działa Claude Code: model mentalny

Przed zagłębieniem się w funkcje warto zrozumieć, jak architektura Claude Code kształtuje 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 i jakość spada. Ta warstwa kosztuje za każdy token.

Warstwa delegacji (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 usługi zewnętrzne (bazy danych, GitHub, Sentry). Hooks gwarantują wykonanie poleceń powłoki niezależnie od zachowania modelu. Skills kodują wiedzę dziedzinową, 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 jak kontekst rośnie, a koszty rosną. Zaawansowani użytkownicy przenoszą eksplorację i wyspecjalizowane zadania do warstwy delegacji, utrzymują warstwę rozszerzeń skonfigurowaną pod swój przepływ pracy, a warstwy podstawowej używają wyłącznie do orkiestracji i podejmowania końcowych 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. Jaki 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 wyjścia
14. Polecenia slash
15. Jak działają skills?
16. System plugins
17. Jak działa pamięć?
18. Obrazy i wejście multimodalne
19. Jak działa integracja z Git?
20. Jak używać Claude Code w IDE?
21. Zaawansowane wzorce użycia
22. Agenty zdalne i w tle [PODGLĄD BADAWCZY]
23. Claude in Chrome
24. Claude Code in Slack [PODGLĄD BADAWCZY]
25. Optymalizacja wydajności
26. Jak debugować problemy?
27. Wdrożenia korporacyjne
28. Skróty klawiszowe — informator
29. Najlepsze praktyki
30. Przepisy na przepływy pracy
31. Przewodnik migracji
32. Wskazówki dla konkretnych grup odbiorców
33. Skrócona karta referencyjna
34. Dziennik zmian
35. Ź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+ przez WSL lub Git Bash. System wymaga minimum 4 GB RAM i 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 przez npm wyświetlają komunikat o wycofaniu. Natywny plik binarny jest teraz zalecaną metodą instalacji. Migracja za pomocą claude install.

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

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

Nigdy nie należy używać sudo przy instalacji przez npm. Powoduje to problemy z uprawnieniami, które komplikują wszystko na dalszych etapach.

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 (rozliczenia API)

Bezpośrednie połączenie z API Anthropic przez platform.claude.com (wcześniej console.anthropic.com). Należy utworzyć konto, skonfigurować rozliczenia i uwierzytelnić się przez CLI. Console zapewnia rozliczenia oparte na zużyciu 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

Używane są dane logowania z konta claude.ai. Subskrypcja obejmuje zarówno interfejs webowy, jak i korzystanie z CLI w ramach jednego miesięcznego planu. 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 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 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 również: Jak debugować problemy? w celu rozwiązywania problemów z uwierzytelnianiem.

Aktualizacje

Claude Code domyślnie aktualizuje się automatycznie, sprawdzając dostępność aktualizacji przy uruchomieniu i okresowo podczas 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. Poproś 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. Korzystanie ze skrótów klawiszowych 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: Utwórz plik CLAUDE.md w katalogu głównym projektu z poleceniami budowania, konwencjami kodowania i notatkami dotyczącymi architektury. Claude odczytuje go przy każdej sesji — to pojedyncze działanie o największym wpływie na jakość.

Podstawowe tryby interakcji

Interaktywny REPL

Uruchom Claude Code bez argumentów, aby wejść w interaktywną pętlę read-eval-print:

cd your-project
claude

REPL zachowuje kontekst rozmowy między kolejnymi zapytaniami. Wpisz zapytanie bezpośrednio, otrzymaj odpowiedź i kontynuuj, aż zakończysz sesję poleceniem /exit lub skrótem Ctrl+D.

Rozpocznij z początkowym promptem, aby ukierunkować sesję:

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 poleceniem /compact lub dodać własne instrukcje określające, co powinno zostać zachowane.

Tryb nieinteraktywny

Tryb print (-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

Dla ustrukturyzowanych danych wyjściowych nadających się do parsowania w skryptach:

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

Dane wyjściowe JSON zawierają wszystko, czego potrzeba 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"
}

Do przetwarzania strumieniowego danych wyjściowych 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:

Kontrolowanie 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 zachowują historię rozmowy do późniejszego kontynuowania. Trwałość sesji jest niezbędna przy złożonej pracy obejmującej wiele sesji:

# 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+): Rozpocznij 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 również wtedy, gdy tworzysz je za pomocą gh pr create podczas sesji. Ułatwia to późniejsze wznowienie pracy nad konkretnym PR.

Nazwane sesje (grudzień 2025): Nazywaj sesje i zarządzaj nimi dla łatwego przywołania:

# 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żyć /rename i --resume.

Claude Code przechowuje sesje jako transkrypcje JSONL. Wykonanie agentowe 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 tylko do odczytu — bez edycji plików, bez wykonywania poleceń bash, bez destrukcyjnych działań. Claude projektuje podejście do implementacji, zapisuje je w pliku planu i czeka na zatwierdzenie przed wykonaniem czegokolwiek.

Wejście w tryb planowania:

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

# 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 przez Shift+Tab)
2. Eksploruje bazę kodu za pomocą narzędzi tylko do odczytu: Read, Glob, Grep, WebSearch, WebFetch
3. Zapisuje plan w .claude/plans/{session-slug}.md
4. Wychodzi z trybu planowania za pomocą ExitPlanMode, przedstawiając plan do przeglądu
5. Zatwierdzasz, prosisz o zmiany lub odrzucasz

Dostępne narzędzia w trybie planowania: Read, Glob, Grep, LS, WebSearch, WebFetch, AskUserQuestion. Narzędzia do edycji (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, każda zmiana wymaga zatwierdzenia - „Tak, automatycznie akceptuj edycje” — zachowuje kontekst, Claude wykonuje bez zatwierdzania poszczególnych edycji

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

Kiedy używać trybu planowania: - Implementacja nowych funkcji z decyzjami architektonicznymi - Refaktoryzacje obejmujące wiele plików, gdy chcesz wcześniej przejrzeć podejście - Nieznane bazy kodu, w których eksploracja powinna poprzedzać modyfikację - Każde zadanie, w którym istnieje wiele prawidłowych podejść i chcesz uzyskać opinię

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

Szczegółowe omówienie 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 obejście.

Hierarchia konfiguracji

Wskazówka dla zaawansowanych: Należy używać .claude/settings.local.json dla osobistych preferencji w projektach współdzielonych (należy dodać go do .gitignore). .claude/settings.json służy do konfiguracji zespołowej, która jest zapisywana w systemie kontroli wersji.

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
  }
}

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

Kontrola zachowania:

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]

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 znacząco wpływa zarówno na koszty, jak i na jakość. Claude Code zapewnia 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 (beta), maksymalnym wyjściem 128K, adaptacyjnym myśleniem i zespołami agentów.⁸⁶ Taki sam cennik jak Opus 4.5 (5 $/25 $ za MTok). Długi kontekst (>200K wejścia) 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 w claude.ai i Claude Cowork.¹⁰⁰ Taki sam cennik jak Sonnet 4.5 (3 $/15 $ za MTok). Ulepszona wydajność wyszukiwania agentowego przy mniejszym zużyciu tokenów. Obsługuje rozszerzone myślenie, adaptacyjne myślenie oraz okno kontekstowe 1M tokenów (beta). Maksymalne wyjście 64K. Granica wiedzy: sierpień 2025 (wiarygodna), styczeń 2026 (dane treningowe). ID modelu: claude-sonnet-4-6. Sonnet 4.5 jest teraz modelem legacy.¹⁰⁰

Dlaczego te różnice cenowe mają znaczenie: Typowa sesja programowania 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: Do subagentów wykonujących eksplorację, prostych wyszukiwań plików, szybkich pytań. Jest ~5 razy tańszy niż Opus i odpowiada szybciej. Idealny do zadań w tle, gdzie głębokie rozumowanie nie jest potrzebne.

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

Opus: Warto 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 określa głębokość rozumowania. Według Anthropic, w Terminal-Bench 2.0 Opus 4.6 osiąga najwyższy w branży wynik agentowego programowania. W GDPval-AA (ekonomicznie wartościowa praca intelektualna) Anthropic podaje, że przewyższa GPT-5.2 o ~144 punkty Elo.⁸⁶ Uwaga: Użytkownicy z subskrypcją Pro mają dostęp do Opus w ramach subskrypcji.²⁰

Opusplan: Tryb hybrydowy wykorzystujący Opus do planowania (gdzie jakość rozumowania jest najważniejsza) i Sonnet do wykonania (gdzie liczy się szybkość). Doskonały do złożonego refaktoringu, gdy potrzebny jest najlepszy plan, ale rozumowanie na poziomie Opus nie jest konieczne 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

W przypadku 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 (beta)

Lub w trakcie sesji:

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

Opus 4.6 to pierwszy model klasy Opus z natywną obsługą kontekstu 1M. Osiąga 76% dokładności w wariancie 8-needle 1M testu MRCR v2 (konkurenci uzyskują ~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). Warto go używać, gdy jest faktycznie potrzebny, a nie jako ustawienie domyślne.

Sprawdzanie bieżącego modelu

> /status

Polecenie pokazuje bieżący model, informacje o koncie, zastosowane ustawienia i inne dane sesji.

Etykiety wyboru modelu (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 przełą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 zapytaniami powyżej 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 cenami za długi kontekst. Tryb szybki nie jest dostępny z Batch API.

Kiedy używać trybu szybkiego: - Szybkie iterowanie nad małymi zmianami, gdy opóźnienie jest wąskim gardłem - Generowanie testów, kodu szablonowego lub powtarzalnego kodu, gdzie szybkość jest ważniejsza niż koszt - Sekwencyjne przetwarzanie listy podobnych zadań

Kiedy NIE używać trybu szybkiego: - Długotrwałe zadania agentowe (koszty szybko rosną przy 6-krotnych stawkach) - 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 ekspercka: Tryb szybki dobrze współgra z trybem hybrydowym opusplan: można używać trybu szybkiego podczas fazy wykonania Sonnet dla szybkiej iteracji, zachowując standardowe stawki dla planowania Opus. Uwaga: /fast wymaga wcześniejszego włączenia /extra-usage (poprawka v2.1.37).⁹³

Ile kosztuje Claude Code?

Zrozumienie i kontrolowanie kosztów jest niezbędne do zrównoważonego korzystania z Claude Code. Zobacz także Wybór modelu, aby poznać możliwości poszczególnych modeli, oraz Ramki decyzyjne, aby dobrać odpowiedni model do 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 użycie powyżej limitu 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 (>200 tys. tokenów wejściowych):

Próg 200 tys. opiera się na łącznej liczbie tokenów wejściowych (w tym odczytów/zapisów pamięci podręcznej). Po jego przekroczeniu Anthropic nalicza wszystkie tokeny według stawki za długi kontekst.¹

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

Buforowanie promptów znacząco obniża koszty powtarzających się danych wejściowych: zapis do pamięci podręcznej kosztuje 1,25× stawki bazowej (pamięć podręczna 5-minutowa) lub 2× (pamięć podręczna 1-godzinna), ale odczyt z pamięci podręcznej kosztuje zaledwie 0,1× — oszczędność 90%. W przypadku systemów RAG i asystentów kodu z powtarzalnym kontekstem buforowanie może obniżyć koszty o 88-95%.

Przetwarzanie wsadowe 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 posiadanie wielu kont, gdy służą one różnym celom.

Co jest dozwolone:

Ograniczenia techniczne: - Do 3 kont można zweryfikować 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 Zasadami użytkowania): - Tworzenie kont w celu obejścia banów po zablokowaniu - Koordynowanie złośliwych działań między kontami w celu uniknięcia wykrycia - Używanie wielu kont do obchodzenia limitów częstotliwości lub darmowych kredytów

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

W razie wątpliwości: Skontaktuj się z pomocą techniczną Anthropic, aby uzyskać pisemne potwierdzenie swojej konkretnej konfiguracji.

Czynniki wpływające na koszty

Przykłady kosztów z praktyki

Wskazówka dotycząca oszczędności: Używanie Haiku dla subagentów eksploracyjnych i Sonnet do implementacji zazwyczaj 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

Oprócz cen za tokeny, niektóre narzędzia wiążą się z dodatkowymi opłatami:¹⁶

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

Strategie oszczędzania kosztów

1. Używaj Haiku dla subagentów: Większość eksploracji nie wymaga Sonnet
2. Włącz buforowanie promptów: Jest domyślnie włączone, ale upewnij się, że nie zostało wyłączone
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 dane wyjściowe: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Przetwarzanie wsadowe API dla zadań niepilnych: 50% zniżki zarówno na tokeny wejściowe, jak i wyjściowe

Monitorowanie użycia

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

Zużycie 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)⁵³

Programowy dostęp do analityki użycia Claude Code w organizacji i metryk produktywności 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-y) - Metryki użycia narzędzi (współczynniki akceptacji/odrzucenia dla Edit, Write itp.) - Śledzenie i alokacja kosztów między zespołami - Uzasadnienie ROI dla narzędzi kodowania z AI

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

Ramy decyzyjne

Sama znajomość funkcji nie wystarczy. Trzeba wiedzieć, kiedy z każdej skorzystać. Poniższe 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. Dla subagents przejdź na Haiku. 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ć pełną kontrolę nad momentem uruchomienia?
│
├── TAK → Użyj Slash Command
│         Przykład: /deploy, /test, /security-review
│         Sam decydujesz o uruchomieniu i momencie.
│
└── NIE → Czy wiedza ekspercka powinna być stosowana automatycznie w zależności od 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 Subagent (narzędzie Task)
                  │         │         Przykład: Głęboka eksploracja, równoległa analiza
                  │         │         Zapobiega rozrostowi kontekstu w głównej konwersacji.
                  │         │
                  │         └── WIELE → Użyj Agent Team (v2.1.32+)
                  │                   Przykład: 5 agentów przeglądających jednocześnie różne moduły
                  │                   Opus koordynuje; każdy agent pracuje niezależnie.
                  │
                  └── NIE → Po prostu wpisz polecenie 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 zadecydować inaczej.
│
└── NIE → Użyj Prompt (probabilistyczny)
         Przykłady:
         - „Rozważ dodanie testów"
         - „Pomyśl o przypadkach brzegowych"
         - „Sprawdź bezpieczeństwo, jeśli to istotne"
         Claude decyduje na podstawie kontekstu.

Kiedy używać rozszerzonego myślenia?

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

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

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ń ręczna 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 wykonania?

Gdzie powinna zostać wykonana ta praca?
│
├── Wymaga TWOICH lokalnych plików i narzędzi
│   │
│   ├── Interaktywna, iteracyjna praca → Główna sesja REPL
│   ├── Jednorazowe skryptowane zadanie → claude -p "prompt" (tryb print)
│   ├── Automatyzacja CI/CD → claude -p --json (nieinteraktywny + strukturalne wyjście)
│   └── Równoległe izolowane zadania → Subagents przez narzędzie Task
│
├── Wymaga CUDZEGO środowiska
│   │
│   └── Zdalny kod źródłowy lub serwer → Background agent (chmura)
│
└── Nie wymaga żadnego środowiska
    │
    ├── Badania lub analiza → Subagent typu Explore
    └── Ekstrakcja treści z sieci → Narzędzia WebFetch / WebSearch

Agent Teams, subagents i sesje równoległe

Czy potrzebujesz wielu agentów pracujących nad powiązanymi podzadaniami?
│
├── TAK → Czy podzadania są niezależne (bez współdzielonego stanu)?
│         │
│         ├── TAK → Czy mogą współdzielić tę samą bazę kodu?
│         │         │
│         │         ├── TAK → Użyj Agent Team (v2.1.32+)
│         │         │         Opus koordynuje. Agenci współdzielą dostęp do repozytorium.
│         │         │         Przykład: „Przejrzyj 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 subagents
│                  Wyniki jednego zasilają następny.
│                  Przykład: „Explore → Plan → Implement"
│
└── NIE → Użyj pojedynczego subagent lub głównej sesji 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"
│
├── Zmodyfikować system prompt 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 ocenić sytuację przed kontynuowaniem?
    │
    └── 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 przełącza tryb szybki dla bieżącej sesji. Używa tego samego modelu (Opus 4.6) ze zoptymalizowaną szybkoś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. Zobacz również Wdrożenie korporacyjne, aby poznać zarządzane ustawienia wymuszające uprawnienia w całej organizacji.

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, wyszukiwanie 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 symbol jest zdefiniowany - Wyszukiwanie 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 ze wsparciem LSP - Wymaga dostępnego serwera języka (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 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 zostanie to jawnie skonfigurowane inaczej.

Tryby uprawnień

Tryb YOLO (v2.0.68+): Aby uzyskać w pełni autonomiczne działanie, należy użyć flagi --dangerously-skip-permissions. Flaga ta zatwierdza wszystko: edycje plików, polecenia bash, wszystkie wywołania narzędzi. Słowo „dangerous” (niebezpieczny) jest celowe. Należy używać w izolowanych środowiskach lub gdy w pełni ufamy bazie kodu.⁶¹

claude --dangerously-skip-permissions

Ustawianie trybu przez CLI:

claude --permission-mode acceptEdits

Przełączanie podczas sesji:

Shift+Tab  # Cycles through modes

W 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 prefiksowe: Bash(npm run test:*) pozwala na npm run test, npm run test:unit i npm run test:integration.

Ważne ograniczenie: Wzorce Bash dopasowują tylko prefiksy, nie wyrażenia regularne. Wzorzec taki jak Bash(curl http:*) nie dopasuje curl -X GET http://..., ponieważ opcje występują przed URL-em. Aby niezawodnie zablokować polecenie, należy zabronić go w całości: 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/**) - zaczyna 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__* pozwala zezwolić lub zabronić wszystkich narzędzi z konkretnego serwera MCP.³⁹ Składnia z symbolami wieloznacznymi 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łączenie 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 - Niektóre polecenia wyłączone z ograniczeń piaskownicy - Polecenia Bash automatycznie zatwierdzane, jeśli autoAllowBashIfSandboxed jest ustawione na true

Wskazówka dla zaawansowanych: Tryb piaskownicy jest doskonały do uruchamiania Claude na niezaufanych bazach kodu. Należy go włączyć podczas eksploracji nieznanych projektów lub gdy potrzebna jest dodatkowa warstwa ochrony. Wewnętrzne testy Anthropic wykazały, że piaskownica redukuje zapytania o uprawnienia o 84%.⁴⁵ Piaskownica wykorzystuje mechanizmy na poziomie systemu operacyjnego (macOS seatbelt, Linux bubblewrap) do izolacji systemu plików i sieci, więc nawet udany atak prompt injection jest w pełni ograniczony. Anthropic udostępnił środowisko uruchomieniowe piaskownicy jako open source dla zespołów tworzących własnych agentów.⁸⁹

Uwagi dotyczące bezpieczeństwa (v2.1.34+): Polecenia wyłączone z piaskownicy poprzez sandbox.excludedCommands lub dangerouslyDisableSandbox mogły wcześniej omijać regułę zapytania o uprawnienia Bash, gdy autoAllowBashIfSandboxed było włączone; zostało to naprawione w v2.1.34.⁹⁴ Od wersji v2.1.38 zapisy do .claude/skills są blokowane w trybie piaskownicy, co zapobiega modyfikowaniu definicji skills przez prompt injection.⁹⁵

Jak działają hooks?

Hooks wykonują deterministyczne polecenia powłoki w określonych punktach przepływu pracy Claude Code. W przeciwieństwie do nakłaniania Claude do wykonywania działań, hooks gwarantują wykonanie niezależnie od zachowania modelu. Są niezbędne do egzekwowania standardów zespołu i automatyzacji powtarzalnych zadań. Zobacz Ramy decyzyjne, aby zapoznać się z drzewem decyzyjnym „Który typ hook?” obejmującym hooks typu command, prompt i agent.

Dlaczego hooks zamiast promptów: Powiedzenie Claude „zawsze uruchamiaj Prettier po edycji plików” działa czasami. Ale Claude może zapomnieć, nadać priorytet szybkości lub uznać, że zmiana jest „zbyt mała”. Hooks gwarantują wykonanie: każdy Edit lub Write uruchamia formatter, za każdym razem, bez wyjątków. W przypadku zgodności, bezpieczeństwa i standardów zespołu deterministyczne podejście przewyższa probabilistyczne.⁷

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"
}

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ć wynik 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 szczegółowym (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, itp.: Błąd nieblokujący: operacja jest kontynuowana. Stderr wyświetlane jako ostrzeżenie w trybie szczegółowym.

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 bogatszej kontroli: trzy wyniki (allow/deny/ask) plus możliwość modyfikacji danych wejściowych narzędzia i wstrzyknięcia 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. Należy używać hookSpecificOutput.permissionDecision i hookSpecificOutput.permissionDecisionReason. Inne zdarzenia (PostToolUse, Stop, itp.) nadal używają decision na najwyższym poziomie.⁹⁶

Asynchroniczne hooks (styczeń 2026)

Hooks mogą teraz działać w tle bez blokowania wykonania Claude Code. Należy 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 się zakończyć przed następną 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+)

Oprócz hooks poleceń powłoki (type: "command"), Claude Code obsługuje dwa typy hooks zasilane przez 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 JSON zdarzenia 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 poleceń (zwracają JSON z decision i reason). Są kierowane przez proxy sieciowe sandbox, gdy sandboxing jest włączony. Nieobsł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 sprawdzanie 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 JSON hook. 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 interpolujące zmienne środowiskowe w nagłówkach wymagają teraz jawnej listy allowedEnvVars. Zapobiega to arbitralnej eksfiltracji zmiennych środowiskowych przez wartości nagłówków. Hooks HTTP są również kierowane przez proxy sieciowe sandbox, 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 do workspace hooks (v2.1.51+): Polecenia hooks statusLine i fileSuggestion wymagają teraz akceptacji zaufania do 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 kodu:

{
  "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

Aby rozwiązywać problemy z hooks, należy włączyć tryb debugowania:

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)

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 skills i polecenia slash) zapewnia, że hook zostanie uruchomiony tylko raz na sesję, co jest przydatne do zadań czyszczenia lub finalizacji.

Strategia dla długotrwałych sesji

W przypadku nocnych lub nienadzorowanych sesji Claude Code należy skonfigurować hooks, aby utrzymać Claude na właściwym torze bez ręcznej interwencji. Kluczowa obserwacja: hooks lintingu i testowania działają jako barierki ochronne, zmuszając Claude do naprawienia problemów przed kontynuowaniem.⁶⁴

Wzorzec „Nie kończ, 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. Kontrola wstępna: 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 przed ogłoszeniem „gotowe” przez Claude
4. Powiadomienia: Hooks Stop mogą powiadamiać przez Slack/Pushover, gdy Claude zakończy pracę lub utknie

W połączeniu z --dangerously-skip-permissions w kontenerze sandbox umożliwia to w pełni autonomiczne sesje nocne. 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ć PR-y na GitHub, sprawdzać błędy w Sentry i komunikować się 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. Wskazówki dotyczące wyboru między MCP a innymi mechanizmami rozszerzeń znajdują się w sekcji Decision Frameworks.

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 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. Stanowi to pomost między interfejsem webowym a CLI: serwery MCP skonfigurowane przez interfejs claude.ai są automatycznie dostępne w Claude Code bez konieczności ponownej konfiguracji lokalnej.¹⁰²

Wyłączenie: 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ę rozbudowy serwerów MCP (niektóre udostępniają ponad 50 narzędzi) opisy narzędzi zaczęły zajmować zbyt dużo kontekstu. Wyszukiwanie narzędzi MCP rozwiązuje ten problem poprzez dynamiczne ładowanie opisów narzędzi tylko wtedy, gdy są potrzebne — to forma leniwego ładowania dla narzędzi AI.⁵⁴

Wpływ na wydajność: Wewnętrzne testy porównawcze wykazują znaczącą poprawę dokładności: - Opus 4: 49% → 74% w ewaluacjach MCP - Opus 4.5: 79,5% → 88,1% w ewaluacjach MCP - Redukcja zużycia 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: Przy włączonym wyszukiwaniu 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 konkurowały o kontekst, teraz współistnieją bezproblemowo.

Interaktywny kreator konfiguracji MCP

Uruchomienie claude mcp add bez argumentów uruchamia krok po kroku interfejs dodawania serwerów MCP. Kreator prowadzi 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

Windows wymaga wrappera 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 za pomocą 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 wyjście MCP, aby zapobiec przepełnieniu kontekstu: - Próg ostrzeżenia: 10 000 tokenów - Domyślne maksimum: 25 000 tokenów

W razie potrzeby można zwiększyć:

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ć zasady 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 odrzuconych 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, które umożliwia interaktywne interfejsy narzędzi bezpośrednio w 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 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 obecnie pojawiają się 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 wersji beta, zastępując dotychczasowy sandbox oparty wyłącznie na Python wykonywaniem poleceń Bash i bezpośrednią manipulacją plikami.⁷⁹ Kluczowe zmiany: - Wykonywanie poleceń Bash (nie tylko Python) w kontenerach sandbox - Pisanie i uruchamianie kodu w dowolnym języku - Programatyczne wywoływanie narzędzi (również w publicznej becie): Claude może wywoływać narzędzia z poziomu wykonywania kodu, redukując opóźnienia i zużycie tokenów w przepływach pracy z wieloma narzędziami

Narzędzie v2 dotyczy przede wszystkim użytkowników API, ale wskazuje kierunek rozwoju możliwości wykonywania kodu w chmurze w Claude Code.

Czym są subagents?

Subagents to wyspecjalizowane instancje Claude, które samodzielnie obsługują złożone zadania. Stanowią jedną z najpotężniejszych funkcji Claude Code i jedną z najmniej zrozumianych. Opanowanie subagents drastycznie rozszerza zakres tego, co można osiągnąć. Więcej informacji w sekcji Decision Frameworks, która zawiera wskazówki dotyczące wyboru między Agent Teams, Subagents i sesjami równoległymi.

Dlaczego subagents istnieją: Główna rozmowa Claude Code posiada jedno okno kontekstowe. Wszystko, co jest omawiane, każdy plik odczytany przez Claude, każde wyjście narzędzia — wszystko to zużywa kontekst. W długich sesjach kontekst się zapełnia, Claude traci orientację w wcześniejszych decyzjach, a wydajność spada. Subagents rozwiązują ten problem poprzez izolację pracy: wyniki eksploracji nie obciążają głównej rozmowy — zwracane jest jedynie podsumowanie. Claude może również uruchamiać do 10 subagents równolegle, umożliwiając jednoczesną pracę, która byłaby niemożliwa sekwencyjnie.²

Jak działają subagents

Gdy Claude napotka zadanie wymagające skupionej uwagi (dogłębna eksploracja, wieloetapowa analiza, wyspecjalizowana praca), może uruchomić subagent. Subagent:

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

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

Wbudowane typy subagents

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, poznawanie struktury

General-purpose: - Model: Sonnet - Tryb: Pełny odczyt/zapis - Narzędzia: Wszystkie dostępne narzędzia - Zastosowanie: Złożone zadania wymagające badania i modyfikacji

Plan: - Model: Sonnet (lub Opus z opusplan) - Tryb: Tylko do odczytu - Narzędzia: Read, Glob, Grep, Bash - Zastosowanie: Planowanie złożonych implementacji przed ich realizacją

Wyzwalanie subagents

Claude automatycznie deleguje zadania do subagents na podstawie typu zadania. 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 subagent. Polecenie „Use an explore agent to find…” zapobiega rozrostowi kontekstu w głównej rozmowie.

Tworzenie własnych subagents

Subagents 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 konfiguracji:

Ograniczanie uruchamianych subagents (v2.1.33+, zmiana nazwy v2.1.63): Pole tools obsługuje składnię Agent(agent_type) w celu ograniczenia typów subagents, które agent może uruchamiać. Na przykład tools: Read, Grep, Agent(Explore) pozwala agentowi bezpośrednio używać Read i Grep, ale delegować tylko do subagents typu Explore. To ograniczenie zapobiega nadmiernej delegacji w agentach z ograniczeniami. Uwaga: W wersji 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 wstecznej kompatybilności.¹¹³

Subagents definiowane przez CLI (v2.1.32+)

Subagents można definiować jako JSON przy uruchomieniu w celu szybkiego testowania lub automatyzacji. Istnieją one tylko przez czas trwania 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 subagents oparte na plikach: description, prompt, tools, disallowedTools, model, permissionMode, mcpServers, hooks, maxTurns, skills i memory.

Zarządzanie subagents

> /agents                    # Interactive management
> /agents create             # Create new subagent
> /agents edit               # Modify existing
> /agents delete             # Remove subagent
> /agents list               # View all

Lista 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 kompilacji, umożliwiając wszystkim użytkownikom zdalny dostęp do możliwości lokalnego środowiska:¹⁰⁵

claude remote-control        # Start serving local environment for external builds

Uruchamianie agentów w tle

Dla długotrwałych zadań:

> Run a thorough security review in the background

> /agents  # Check status of running agents

Wyniki można pobrać później za pomocą identyfikatora agenta.

Zaawansowane wzorce

Łączenie subagents w łańcuch:

> 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

Wznawianie agentów: Agentów można wznowić za pomocą ich identyfikatora, aby kontynuować wcześniejszą pracę:

> Resume agent abc123 and continue the analysis

Asynchroniczne subagents (grudzień 2025)

Asynchroniczne subagents 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 za pośrednictwem zunifikowanego TaskOutputTool, umożliwiając wydajne przepływy pracy w stylu potoku.

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

Od wersji v2.1.0 subagents kontynuują pracę po odmowie uprawnień, zamiast całkowicie się zatrzymywać. Gdy subagent napotka ścianę 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 (team lead), uruchamiając współpracowników (teammates), którzy pracują niezależnie we własnych oknach kontekstowych, komunikując się bezpośrednio za pomocą współdzielonej skrzynki pocztowej i listy zadań.⁸⁶⁹¹

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

Włączenie:

// 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.

Klawisze sterujące: - Shift+Down: Przełączanie między teammates (tryb in-process; po ostatnim teammate wraca do lidera) - Shift+Tab: Włączenie trybu delegacji (ogranicza lidera wyłącznie do koordynacji, bez zmian w kodzie) - Ctrl+T: Przełączanie współdzielonej listy zadań - Enter na teammate: Podgląd sesji; Escape aby przerwać turę

Kiedy używać Agent Teams zamiast subagents:

Najlepsze przypadki użycia: - Badanie i przegląd (wiele perspektyw jednocześnie) - Nowe moduły/funkcje (teammates posiadają oddzielne fragmenty) - Debugowanie z konkurencyjnymi hipotezami (testowanie różnych teorii równolegle) - Koordynacja międzywarstwowa (frontend, backend, testy — każde obsługiwane przez innego teammate)

Zatwierdzanie planów teammates: W przypadku złożonych lub ryzykownych zadań można wymagać od teammates zaplanowania przed implementacją. Teammate pracuje w trybie planu tylko do odczytu, dopóki lider nie przejrzy i nie zatwierdzi 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 polecenia:

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 polami 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: Hooks TeammateIdle (kod wyjścia 2 wysyła feedback i utrzymuje teammate w pracy) oraz TaskCompleted (kod wyjścia 2 zapobiega ukończeniu) służą do wymuszania bramek jakości na teammates.

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

Agent Skills (grudzień 2025)

Agent Skills to zorganizowane foldery instrukcji, skryptów i zasobów, które agenty dynamicznie odkrywają i ładują.³¹ Zapewniają one komponowalną, przenośną wiedzę domenową:

.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 i zadaniach wymagających starannej analizy.

Obecny stan (styczeń 2026)

Rozszerzone myślenie jest teraz domyślnie włączone z budżetem 31 999 tokenów — maksymalnym budżetem, który wcześniej był uruchamiany przez „ultrathink”.⁷⁰ Anthropic wprowadził tę zmianę, ponieważ rozszerzone myślenie znacząco poprawia wydajność przy złożonych zadaniach planowania i rozumowania.

Ważne: Naturalne wyzwalacze językowe, takie jak „think”, „think hard”, „think harder” i „ultrathink”, już nie działają. Claude interpretuje teraz te słowa kluczowe jako zwykłe instrukcje promptu i nie przydziela tokenów myślenia. Budżet myślenia jest kontrolowany wyłącznie przez zmienną środowiskową MAX_THINKING_TOKENS lub poprzez /config.⁷⁰

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

Sterowanie rozszerzonym myśleniem

Szybkie przełączanie podczas sesji:

Press Alt+T to toggle thinking on/off

Uwaga: Anthropic zmienił skrót przełączania 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 (na stałe):

# 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 kosztów: Przy prostszych zadaniach, gdzie głębokie rozumowanie nie jest potrzebne, można obniżyć koszty, wyłączając myślenie w /config lub zmniejszają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 dobrze 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 danych wyjściowych. Claude Code szyfruje proces myślenia i zwraca go 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 warto rozważyć wyłączenie/zmniejszenie

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

Zachowanie pamięci podręcznej

Claude Code zachowuje buforowanie promptu systemowego, gdy zmieniają się parametry myślenia. Zmiana budżetu myślenia lub statusu włączenia między turami unieważnia buforowanie wiadomości.

Style wyjściowe

Style wyjściowe dostosowują sposób prezentacji informacji przez Claude, co jest przydatne przy nauce, dokumentacji lub specyficznych preferencjach zespołu.¹⁹

Wbudowane style

Ustawianie stylu wyjściowego

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

Lub poprzez ustawienia:

{
  "outputStyle": "Explanatory"
}

Niestandardowe style wyjściowe

Należy je utworzyć 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.

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 przy typowych operacjach.

Dokumentacja wbudowanych poleceń

Tworzenie niestandardowych poleceń

Polecenia wielokrotnego użytku można tworzyć w .claude/commands/ (projekt) 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.

Zapisać jako .claude/commands/security-review.md, wywołać za pomocą /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

Wykonywanie poleceń bash 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

Dołączanie zawartości plików do poleceń:

---
description: Compare implementations
---

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

Which implementation is more maintainable?

Przestrzenie nazw poleceń

Organizacja poleceń 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. Osadzasz wiedzę domenową w skill, a Claude czerpie z tej wiedzy zawsze, gdy sytuacja tego wymaga, bez konieczności pamiętania o zadaniu pytania.

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

To rozróżnienie ma znaczenie. Polecenie slash to skrót, o którego użyciu trzeba pamiętać. Skill to wiedza, którą Claude ma zawsze do dyspozycji. Gdy utworzymy skill przeglądu bezpieczeństwa z konkretnymi wzorcami podatności i wymaganiami zgodności naszego zespołu, Claude stosuje tę wiedzę za każdym razem, gdy napotka odpowiedni kod — czy to podczas przeglądów PR, refaktoryzacji, czy jakiegokolwiek zadania związanego z bezpieczeństwem. Nie wywołujemy /security-review; Claude rozpoznaje kontekst i stosuje skill automatycznie.

Skills a polecenia i subagents

Zrozumienie, kiedy używać poszczególnych mechanizmów rozszerzania, zapobiega duplikacji i maksymalizuje efektywność:

Polecenia slash stosujemy, gdy chcemy jawnej kontroli: /deploy, /test, /review PR 456. Sami decydujemy, kiedy je uruchomić.

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

Subagents stosujemy, gdy zadania wymagają izolacji: eksploracja w tle, równoległa analiza, specjalistyczne rozumowanie, które nie powinno zanieczyszczać głównej konwersacji.

Struktura i lokalizacja skills

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

Osobiste skills (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

Projektowe skills (współdzielone z zespołem przez git):

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

Projektowe skills trafiają do kontroli wersji. Gdy współpracownicy wykonają pull, automatycznie otrzymują skills — bez instalacji, bez konfiguracji. Automatyczna dystrybucja standaryzuje wiedzę ekspercką w całym zespole.

Format SKILL.md

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

---
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.

Referencja frontmatter

Podstawienia ciągów znaków (v2.1.9+): Skills mogą uzyskać 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. Konkretny opis z jasnymi warunkami wyzwalania oznacza niezawodną aktywację.

Słaby opis:

description: Helps with code

Skuteczny opis:

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, audit, or check code.

Skuteczny opis zawiera: - Co skill robi (przegląd kodu pod kątem konkretnych problemów) - Kiedy go używać (analiza zmian, PR, jakości kodu) - Frazy wyzwalające (review, audit, check)

Ograniczenia narzędzi

Pole allowed-tools ogranicza możliwości Claude, gdy skill jest aktywny. Ograniczenia narzędzi są niezbędne dla skills tylko do odczytu lub o ograniczonym zakresie:

---
name: security-auditor
description: Audit code for security vulnerabilities without making changes
allowed-tools: Read, Grep, Glob
---

Przy takiej konfiguracji Claude może analizować kod, ale nie może edytować plików, uruchamiać poleceń bash ani wprowadzać modyfikacji. Skill wymusza zachowanie tylko do odczytu.

Typowe wzorce ograniczeń:

Pliki pomocnicze

Skills mogą zawierać wiele plików. Claude odczytuje główny SKILL.md przy aktywacji, a następnie uzyskuje dostęp do plików pomocniczych w razie potrzeby — zapewnia to stopniowe ujawnianie informacji, które efektywnie zarządza kontekstem.

Wzorzec struktury:

my-skill/
├── SKILL.md           # Required: overview + quick reference
├── DETAILED_GUIDE.md  # Deep documentation
├── EXAMPLES.md        # Concrete examples
├── PATTERNS.md        # Reference patterns
├── templates/         # Reusable templates
│   └── component.tsx
└── scripts/           # Helper utilities
    └── validate.py

Odwoływanie się do plików pomocniczych z SKILL.md:

For detailed security patterns, see [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md).

Use this template for new components:
@templates/component.tsx

Validate configurations with:
```bash
python scripts/validate.py config.json

**Wskazówka eksperta:** Najważniejsze informacje umieszczaj bezpośrednio w SKILL.md. Pliki pomocnicze przeznacz na szczegółowe materiały referencyjne. Claude odczytuje SKILL.md natychmiast, ale do plików pomocniczych sięga dopiero w razie potrzeby. Jeśli krytyczne informacje są ukryte w pliku pomocniczym, Claude może ich nie znaleźć.

### Kompletny przykład: skill eksperta domenowego

Oto skill o jakości produkcyjnej dla aplikacji fintech:

**Struktura katalogów:**

.claude/skills/payments-domain/ ├── SKILL.md ├── BUSINESS_RULES.md ├── COMPLIANCE.md └── DATA_MODELS.md

**SKILL.md:**
```markdown
---
name: payments-domain
description: Expert knowledge of payment processing domain including transaction flows, compliance requirements, and business rules. Use when working with payment code, transaction handling, refunds, disputes, or financial calculations.
---

# Payments Domain Expertise

## Podstawowe koncepcje

### Stany transakcji

PENDING → AUTHORIZED → CAPTURED → SETTLED ↘ VOIDED AUTHORIZED → DECLINED CAPTURED → REFUNDED (partial or full) SETTLED → CHARGEBACK → REPRESENTED

### Zasady obsługi kwot pieniężnych
- WSZYSTKIE wartości pieniężne przechowywane jako liczby całkowite (centy, nie dolary)
- Waluta zawsze jawnie śledzona (nigdy nie zakładaj USD)
- Zaokrąglanie: HALF_EVEN do obliczeń, HALF_UP do wyświetlania
- Nigdy nie używaj zmiennoprzecinkowych dla kwot pieniężnych

### Wymagania idempotentności
Każda operacja płatnicza MUSI być idempotentna:
```typescript
// Required pattern
async function processPayment(idempotencyKey: string, amount: number) {
  const existing = await findByIdempotencyKey(idempotencyKey);
  if (existing) return existing; // Return cached result

  const result = await executePayment(amount);
  await storeWithIdempotencyKey(idempotencyKey, result);
  return result;
}