Przewodnik Claude Code CLI: instalacja, konfiguracja, polecenia, zmienne środowiskowe

TL;DR: Claude Code to agentowy CLI, który odczytuje bazę kodu, wykonuje polecenia i modyfikuje pliki poprzez warstwowy system uprawnień, hooks, integracji MCP oraz subagentów. Opanowanie pięciu kluczowych systemów (konfiguracja, uprawnienia, hooks, MCP i subagenty) odblokowuje wielokrotne zwiększenie produktywności. Należy wybrać poziom modelu odpowiedni do każdego zadania — Opus do złożonego rozumowania, Sonnet do ogólnej pracy, Haiku do szybkiej eksploracji — lub ujednolicić wybór na Opusie, jeśli jakość jest jedyną zmienną. Do wszystkiego, co musi być zawsze wykonywane, należy używać hooks (nie promptów).

Claude Code działa jako system agentowy, a nie jako interfejs czatu z wiedzą programistyczną. CLI odczytuje bazę kodu, wykonuje polecenia, modyfikuje pliki, zarządza przepływami git, łączy się z usługami zewnętrznymi poprzez MCP oraz deleguje złożone zadania wyspecjalizowanym subagentom. Wszystko przepływa przez interfejs wiersza poleceń, który integruje się ze sposobem, w jaki deweloperzy faktycznie pracują. Według stanu na luty 2026, 4% publicznych commitów GitHub (~135 000 dziennie) jest tworzonych przez Claude Code — co stanowi 42 896-krotny wzrost w ciągu 13 miesięcy od podglądu badawczego — a 90% kodu samej firmy Anthropic jest pisane przez AI.¹¹⁰

Różnica między okazjonalnym a efektywnym użyciem Claude Code sprowadza się do pięciu kluczowych systemów. Po ich opanowaniu Claude Code staje się mnożnikiem produktywności:

1. Hierarchia konfiguracji: kontroluje zachowanie
2. System uprawnień: kontroluje operacje
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 oraz subagenty kontrolują wszystko, od zachowania po automatyzację.
• Należy przekazywać pracę do warstwy delegacji: subagenty zapobiegają przeciążeniu kontekstu, izolując eksplorację w czystych oknach kontekstowych i zwracając jedynie podsumowania.
• Hooks gwarantują wykonanie; prompty nie: warto używać hooks do lintowania, formatowania i kontroli bezpieczeństwa, które muszą być uruchamiane za każdym razem, niezależnie od zachowania modelu.
• Stopniowanie modeli oszczędza koszty bez poświęcania jakości: można kierować eksplorację subagentów do tańszych modeli, a Opus zarezerwować dla rzeczywistego rozumowania architektonicznego — lub ujednolicić wybór na Opusie, jeśli jakość jest jedyną zmienną.
• MCP łączy Claude z łańcuchem narzędzi: bazy danych, GitHub, Sentry oraz ponad 3 000 integracji rozszerzają możliwości Claude poza odczyt plików i polecenia bash.

Spędziłem miesiące, sprawdzając Claude Code na granicach możliwości w produkcyjnych bazach kodu, pipeline’ach CI/CD oraz wdrożeniach korporacyjnych. Niniejszy przewodnik destyluje to doświadczenie w kompletny materiał referencyjny, którego sam potrzebowałem, gdy zaczynałem. Każda funkcja zawiera rzeczywistą składnię, autentyczne przykłady konfiguracji oraz przypadki brzegowe, które potrafią zaskoczyć doświadczonych użytkowników.

Wybór ścieżki

Jak korzystać z tego przewodnika

To dokument referencyjny liczący ponad 5 000 linii — nie trzeba czytać go od deski do deski. Warto zacząć tam, gdzie pasuje poziom doświadczenia:

Można skorzystać ze skrótu Ctrl+F / Cmd+F w przeglądarce, aby wyszukać konkretne flagi, polecenia lub klucze konfiguracji. Quick Reference Card na końcu zawiera czytelne podsumowanie wszystkich głównych poleceń.

Powiązane materiały szczegółowe

Te wpisy blogowe szczegółowo omawiają konkretne aspekty Claude Code:

Szybki start w 60 sekund

Aby po prostu uruchomić Claude Code i zobaczyć wynik, należy wykonać w kolejności:

# 1. Install (pick one)
npm install -g @anthropic-ai/claude-code          # npm users
brew install anthropic/claude/claude              # macOS + Homebrew
curl -sL claude.ai/install.sh | sh                # native installer

# 2. Launch in any project directory
cd ~/your-project && claude

# 3. Authenticate (browser opens automatically on first run)
/login

# 4. Ask your first question
> What does this repo do? Read the key files and summarize.

To wszystko. Pozostała część niniejszego dokumentu rozwija opcje instalacji, konfiguruje uprawnienia i hooks, podłącza serwery MCP oraz omawia wdrożenie w przedsiębiorstwie — niemniej żaden z tych kroków nie jest wymagany, aby rozpocząć pracę.

Wymagania wstępne: Node 18+ (dla ścieżki npm), macOS / Linux / Windows 10+. Subskrypcja Claude Pro, Max, Team lub Enterprise albo rozliczany za token klucz Anthropic API pokrywa użytkowanie. Zobacz Jak zainstalować Claude Code?, aby poznać specyfikę platform, rozwiązywanie problemów oraz ścieżkę natywnego pliku binarnego (domyślną od v2.1.113).

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 rdzenia (Core Layer): Główna konwersacja. Każda wiadomość, odczyt pliku oraz wynik narzędzia zużywa kontekst ze wspólnego okna (standardowo 200K tokenów⁹⁸, 1M tokenów w Opus 4.6 lub modelach z rozszerzonym kontekstem). Gdy kontekst się zapełnia, Claude traci ślad wcześniejszych decyzji, a jakość spada. Ta warstwa kosztuje pieniądze za każdy token.

Warstwa delegacji (Delegation Layer): Subagenci są uruchamiani z czystymi kontekstami, wykonują skoncentrowaną pracę i zwracają podsumowania. Wyniki eksploracji nie obciążają głównej konwersacji — wracają jedynie wnioski. Można kierować subagentów do tańszych poziomów modeli na potrzeby eksploracji lub używać modelu głównego wszędzie, jeżeli jakość liczy się bardziej niż koszt.

Warstwa rozszerzeń (Extension Layer): MCP łączy się z usługami zewnętrznymi (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ą wszystkie te elementy w celu dystrybucji.

Kluczowe spostrzeżenie: Większość użytkowników pracuje wyłącznie w warstwie rdzenia, obserwując rozrost kontekstu i rosnące koszty. Zaawansowani użytkownicy przesuwają eksplorację i wyspecjalizowane zadania do warstwy delegacji, utrzymują warstwę rozszerzeń skonfigurowaną pod swój przepływ pracy, a warstwy rdzenia używają jedynie do orkiestracji i finalnych decyzji.

Spis treści

1. Jak zainstalować Claude Code?
2. Szybki start: pierwsza sesja
3. Podstawowe tryby interakcji
4. Szczegółowe omówienie systemu konfiguracji
5. Jaki model wybrać?
6. Ile kosztuje Claude Code?
7. Ramy podejmowania decyzji
8. Jak działa system uprawnień?
9. Jak działają hooks?
10. Czym jest MCP (Model Context Protocol)?
11. Czym są subagents?
12. Czym jest tryb rozszerzonego myślenia?
13. Style wyjścia
14. Slash commands
15. Jak działają skills?
16. System plugins
17. Jak działa pamięć?
18. Wejście obrazowe i multimodalne
19. Tryb głosowy
20. Jak działa integracja z Git?
21. Jak używać Claude Code w moim IDE?
22. Zaawansowane wzorce użycia
23. Zdalni i działający w tle agenci [RESEARCH PREVIEW]
24. Claude w Chrome
25. Claude Code w Slack [RESEARCH PREVIEW]
26. Claude Code w przeglądarce [RESEARCH PREVIEW]
27. Optymalizacja wydajności
28. Jak debugować problemy?
29. Wdrożenie w przedsiębiorstwie
30. Lista skrótów klawiszowych
31. Najlepsze praktyki
32. Przepisy na przepływy pracy
33. Przewodnik migracji
34. Wskazówki dla konkretnych odbiorców
35. Karta szybkiego dostępu
36. Dziennik zmian
37. Źródła

Jak zainstalować Claude Code?

Wymagania systemowe

Claude Code działa na macOS 13+, Ubuntu 20.04+/Debian 10+ oraz Windows 10+ (natywnie lub WSL). System wymaga co najmniej 4 GB pamięci RAM oraz aktywnego połączenia internetowego.⁹⁹ Najlepszą kompatybilność powłoki zapewniają Bash, Zsh lub Fish.

W przypadku systemu 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

Macierz wsparcia platform

Instalacja, aktualizacja i odinstalowanie w skrócie

Skanowalna ściąga — każda metoda, każde polecenie, sprawdzenie wersji na jednym ekranie. Poniższe podsekcje obejmują szczegóły dotyczące poszczególnych metod oraz rozwiązywanie problemów.

Od v2.1.113 kanoniczne CLI uruchamia natywny plik binarny Claude Code poprzez opcjonalną zależność dla danej platformy zamiast dołączonego JavaScript — należy używać natywnego instalatora dla testowanej dystrybucji. Ścieżka npm nadal działa, ale otrzymuje powiadomienie o wycofaniu wprowadzone w v2.1.15.

Metody instalacji

Natywna instalacja (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 v2.1.15 instalacje npm wyświetlają powiadomienie o wycofaniu. Natywny plik binarny jest obecnie zalecaną metodą instalacji. Migrację można wykonać poleceniem claude install.

W przypadku środowisk legacy, w których nadal potrzebny jest npm:

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

Nigdy nie należy używać sudo przy instalacji npm. Powoduje to problemy z uprawnieniami, które komplikują wszystko w dalszej kolejności.

Migracja z istniejącej instalacji

Jeśli posiada się starszą instalację opartą na npm, można wykonać 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)

Łączy się bezpośrednio z API firmy 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 obszar roboczy „Claude Code” jest tworzony automatycznie; nie można utworzyć kluczy API dla tego obszaru roboczego, ale można monitorować zużycie.

Subskrypcja Claude Pro lub Max

Należy użyć danych logowania konta claude.ai. Subskrypcja pokrywa zarówno interfejs webowy, jak i użycie CLI w ramach jednego miesięcznego planu. Subskrypcja upraszcza rozliczenia dla użytkowników indywidualnych, którzy oczekują 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. Kreator konfiguracji Bedrock (v2.1.92+): Interaktywny kreator na ekranie logowania prowadzi przez uwierzytelnianie AWS, wybór regionu, weryfikację poświadczeń oraz przypinanie modelu.¹⁴⁴ Kreator konfiguracji Vertex AI (v2.1.98+): Pasujący kreator dla Google Cloud, prowadzący przez uwierzytelnianie GCP, konfigurację projektu i regionu, weryfikację poświadczeń oraz przypinanie modelu.¹⁴⁹ Vertex AI mTLS Workload Identity Federation (v2.1.121+): Vertex AI akceptuje teraz Workload Identity Federation oparte na certyfikatach X.509 (mTLS Application Default Credentials) — krótkotrwałe tokeny GCP wybijane z certyfikatu klienta, bez wymogu JSON konta usługi.¹⁶¹ Zaufanie do certyfikatu CA systemu operacyjnego (v2.1.101+): Korporacyjne proxy TLS działają teraz domyślnie — Claude Code ufa magazynowi certyfikatów systemu operacyjnego. Należy ustawić CLAUDE_CODE_CERT_STORE=bundled, aby używać tylko dołączonych urzędów CA.¹⁵⁰

# 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

# Amazon Bedrock via Mantle (v2.1.94+)
export CLAUDE_CODE_USE_MANTLE=1

W przypadku wdrożeń korporacyjnych za serwerami proxy lub przez bramy LLM:

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

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

Weryfikacja

claude doctor

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

Zarządzanie uwierzytelnianiem (v2.1.41+)

Zarządzanie uwierzytelnianiem bez wchodzenia do REPL:⁹⁷

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

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

claude auth logout && claude auth login

Patrz także: Jak debugować problemy?, aby uzyskać informacje o rozwiązywaniu problemów z uwierzytelnianiem.

Aktualizacje

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

Wyłączanie automatycznych aktualizacji:

export DISABLE_AUTOUPDATER=1

Lub w settings.json:

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

Aktualizacja ręczna:

claude update

Odinstalowanie

Natywna instalacja (macOS/Linux/WSL):

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

Natywna instalacja (Windows PowerShell):

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

Czysta konfiguracja (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. Proszę poprosić Claude o wykonanie czegoś:

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

4. Używanie kluczowych skrótów podczas sesji:

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

5. Kontynuacja później:

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

Wskazówka eksperta: Warto utworzyć plik CLAUDE.md w katalogu głównym projektu, zawierający polecenia kompilacji, konwencje kodowania oraz notatki o architekturze. Claude odczytuje go w każdej sesji — to najbardziej skuteczna pojedyncza czynność, jaką można wykonać dla jakości pracy.

Główne tryby interakcji

Interaktywny REPL

Aby wejść w interaktywną pętlę read-eval-print, należy uruchomić Claude Code bez argumentów:

cd your-project
claude

REPL utrzymuje kontekst rozmowy między kolejnymi turami. Można wpisywać zapytania bezpośrednio, otrzymywać odpowiedzi i kontynuować, aż do zakończenia poleceniem /exit lub Ctrl+D.

Aby ukierunkować sesję, warto rozpocząć od początkowego promptu:

claude "explain the authentication flow in this project"

Wskazówka eksperta: REPL zachowuje stan podczas zdarzeń kompaktowania. Gdy kontekst staje się zbyt duży, Claude automatycznie podsumowuje wcześniejszą rozmowę, zachowując kluczowe decyzje i fragmenty kodu. Można uruchomić ten proces ręcznie poleceniem /compact lub dodać własne instrukcje określające, co ma zostać zachowane.

Tryb nieinteraktywny

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

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

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

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

Aby uzyskać uporządkowany wynik nadający się do parsowania w skryptach:

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

Wynik JSON zawiera wszystko, co jest potrzebne do automatyzacji:

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

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

Kody wyjścia:

Sterowanie zachowaniem agentowym 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

# Bare mode: skip hooks, LSP, plugin sync, skill walks (v2.1.81+)
claude -p "count files" --bare

# Channel permission relay: send approval prompts to Telegram/Discord (v2.1.81+)
claude --channels

Wzorzec integracji 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 w celu kontynuacji. Trwałość sesji jest niezbędna w przypadku 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+, rozszerzone v2.1.119+): Można rozpocząć sesję powiązaną z konkretnym pull lub merge requestem. Od wersji v2.1.119 --from-pr akceptuje URL-e GitLab MR, Bitbucket PR oraz GitHub Enterprise PR oprócz github.com:⁸¹¹⁵⁹

claude --from-pr 123                                                # GitHub PR number (assumes current repo's remote)
claude --from-pr https://github.com/org/repo/pull/123               # GitHub URL
claude --from-pr https://gitlab.com/org/repo/-/merge_requests/45    # GitLab MR (v2.1.119+)
claude --from-pr https://bitbucket.org/org/repo/pull-requests/67    # Bitbucket PR (v2.1.119+)
claude --from-pr https://ghe.example.com/org/repo/pull/89           # GitHub Enterprise (v2.1.119+)

Sesje są również automatycznie powiązywane z PR-ami, gdy są tworzone za pomocą gh pr create w trakcie sesji. Dzięki temu można łatwo wznowić pracę nad konkretnym PR-em w późniejszym czasie. Plakietka PR w stopce może wskazywać własny URL przeglądu kodu poprzez ustawienie prUrlTemplate (v2.1.119+) — co jest przydatne, gdy zespół tworzy odnośniki z PR-ów do osobnego narzędzia przeglądu.¹⁵⁹

/resume akceptuje URL-e PR (v2.1.122+). Wklejenie URL-a PR do pola wyszukiwania /resume znajduje teraz sesję, która pierwotnie utworzyła ten PR — działa to dla github.com, GitHub Enterprise, gitlab.com (i samodzielnie hostowanego GitLab) oraz bitbucket.org.¹⁶¹

Nazwane sesje: Sesje można nazywać przy uruchomieniu lub w trakcie sesji:

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

# Name current session
> /rename auth-refactor

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

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

Uwaga: --session-id wymaga prawidłowego UUID (np. 550e8400-e29b-41d4-a716-446655440000). Aby uzyskać czytelne dla człowieka nazewnictwo sesji, należy zamiast tego używać /rename oraz --resume.

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

Tryb planowania

Tryb planowania ogranicza Claude do eksploracji w trybie tylko do odczytu — bez edycji plików, bez wykonywania bash, bez działań destrukcyjnych. 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 use the /plan command with an optional description (v2.1.72+)
/plan                                     # Enter plan mode
/plan refactor the auth module            # Enter plan mode with a description

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

Jak to działa:

1. Claude wchodzi w tryb planowania (automatycznie dla złożonych zadań lub poprzez Shift+Tab)
2. Eksploruje bazę kodu używając narzędzi tylko do odczytu: Read, Glob, Grep, WebSearch, WebFetch
3. Zapisuje plan do .claude/plans/{session-slug}.md
4. Wychodzi z trybu planowania poprzez ExitPlanMode, prezentując plan do przeglądu
5. Można zatwierdzić, poprosić o zmiany lub odrzucić

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

Po zatwierdzeniu planu (v2.1.32+): Claude oferuje trzy opcje: - „Yes, clear context and auto-accept edits” (Shift+Tab) — rozpoczyna od nowa z pełnym kontekstem dla planu - „Yes, and manually approve edits” — zachowuje kontekst, ręczne zatwierdzanie każdej zmiany - „Yes, auto-accept edits” — zachowuje kontekst, Claude wykonuje bez zatwierdzania każdej edycji

Automatyczne czyszczenie kontekstu przy zatwierdzeniu to zalecany przepływ pracy. Daje on planowi świeże okno kontekstowe, co znacząco poprawia trzymanie się planu — Claude pozostaje na właściwym torze dłużej, bez ingerencji starszej rozmowy.

Kiedy używać trybu planowania: - Implementacje nowych funkcji wymagające decyzji architektonicznych - Refaktoryzacje obejmujące wiele plików, gdy najpierw chce się 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 pożądany jest wkład

Wskazówka eksperta: Im więcej czasu spędza się w trybie planowania, tym większe prawdopodobieństwo, że Claude powiedzie się przy implementacji. Tryb planowania to praktycznie darmowa eksploracja — bez ryzykownych wywołań narzędzi, bez zmarnowanych edycji. Warto z niego korzystać szeroko.

Dogłębne omówienie systemu konfiguracji

Claude Code wykorzystuje warstwowy system konfiguracji. Zrozumienie tej hierarchii jest kluczowe, ponieważ wyższe poziomy nadpisują niższe, a ustawień korporacyjnych nie można w żaden sposób obejść.

Hierarchia konfiguracji

Wskazówka eksperta: Plik .claude/settings.local.json warto wykorzystać do osobistych preferencji we współdzielonych projektach (należy dodać go do .gitignore). Plik .claude/settings.json służy do konfiguracji obowiązującej w całym zespole, która jest wprowadzana do systemu kontroli wersji.

Pełna referencja settings.json

Pełna konfiguracja prezentująca wszystkie kluczowe opcje:

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

Referencja zmiennych środowiskowych

Uwierzytelnianie i API:

ANTHROPIC_API_KEY=sk-ant-...                    # Bezpośrednie uwierzytelnianie API
ANTHROPIC_AUTH_TOKEN=token                      # Niestandardowy nagłówek autoryzacji
ANTHROPIC_CUSTOM_HEADERS="X-Key: val"           # Dodatkowe nagłówki żądań

Konfiguracja modelu:

ANTHROPIC_MODEL=claude-opus-4-7                 # Nadpisanie domyślnego modelu (16 kwietnia 2026)
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-7    # Opus 4.7 (domyślny dla Max/Team Premium)
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model dla subagentów
MAX_THINKING_TOKENS=10000                       # (tylko Opus 4.6 i Sonnet 4.6 — usunięte w Opus 4.7)
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Ograniczenie długości wyjścia
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1          # Włączenie zespołów agentów (v2.1.32+)

Konfiguracja dostawcy chmury:

CLAUDE_CODE_USE_BEDROCK=1                       # Używa AWS Bedrock
CLAUDE_CODE_USE_VERTEX=1                        # Używa Google Vertex AI
CLAUDE_CODE_USE_FOUNDRY=1                       # Używa Microsoft Foundry
ANTHROPIC_BEDROCK_BASE_URL=https://...          # Niestandardowy punkt końcowy Bedrock
ANTHROPIC_BEDROCK_SERVICE_TIER=priority         # Poziom usługi Bedrock (v2.1.122+): 'default', 'flex' lub 'priority'; wysyłany jako nagłówek X-Amzn-Bedrock-Service-Tier[^162]
CLAUDE_CODE_SKIP_BEDROCK_AUTH=1                 # Pomija uwierzytelnianie Bedrock (dla bramek)
CLAUDE_CODE_SKIP_VERTEX_AUTH=1                  # Pomija uwierzytelnianie Vertex
AWS_BEARER_TOKEN_BEDROCK=token                  # Token bearer dla Bedrock
VERTEX_REGION_CLAUDE_3_7_SONNET=us-west1        # Nadpisanie regionu Vertex

Kontrola zachowania:

DISABLE_AUTOUPDATER=1                           # Blokuje automatyczne aktualizacje w tle
DISABLE_UPDATES=1                               # Blokuje WSZYSTKIE ścieżki aktualizacji, w tym ręczną `claude update` (v2.1.118+, bardziej restrykcyjne niż DISABLE_AUTOUPDATER)[^160]
DISABLE_TELEMETRY=1                             # Rezygnacja z telemetrii użytkowania
DISABLE_ERROR_REPORTING=1                       # Wyłącza Sentry
DISABLE_BUG_COMMAND=1                           # Wyłącza polecenie /bug
DISABLE_COST_WARNINGS=1                         # Ukrywa ostrzeżenia o kosztach
DISABLE_PROMPT_CACHING=1                        # Globalnie wyłącza buforowanie promptów
DISABLE_PROMPT_CACHING_SONNET=1                 # Wyłącza tylko dla Sonnet
DISABLE_PROMPT_CACHING_OPUS=1                   # Wyłącza tylko dla Opus
DISABLE_NON_ESSENTIAL_MODEL_CALLS=1             # Pomija niekrytyczne wywołania API
ENABLE_PROMPT_CACHING_1H=1                      # Włącza 1-godzinny TTL pamięci podręcznej promptów (v2.1.108+, API/Bedrock/Vertex/Foundry)
ENABLE_PROMPT_CACHING_1H_BEDROCK=1              # Wycofany alias powyższego; v2.1.108+ nadal honoruje go w Bedrock, ale rejestruje powiadomienie o wycofaniu
FORCE_PROMPT_CACHING_5M=1                       # Wymusza 5-minutowe TTL pamięci podręcznej (v2.1.108+)
ENABLE_TOOL_SEARCH=true                         # Ponownie włącza wyszukiwanie narzędzi w Vertex AI (domyślnie wyłączone w v2.1.119+, aby uniknąć nieobsługiwanego nagłówka beta). Dopuszczalne wartości: true, false, auto, auto:N[^160]
CLAUDE_CODE_HIDE_CWD=1                          # Ukrywa katalog roboczy w logo startowym (v2.1.119+)[^160]
CLAUDE_CODE_FORK_SUBAGENT=1                     # Włącza rozdzielone subagenty w buildach zewnętrznych (v2.1.117+)[^160]

Konfiguracja narzędzi:

BASH_DEFAULT_TIMEOUT_MS=30000                   # Limit czasu polecenia Bash (30 s)
BASH_MAX_TIMEOUT_MS=600000                      # Maksymalny limit czasu Bash (10 min)
BASH_MAX_OUTPUT_LENGTH=50000                    # Limit wyjścia Bash
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1     # Resetuje CWD po każdym wywołaniu bash
MCP_TIMEOUT=5000                                # Limit czasu uruchomienia serwera MCP
MCP_TOOL_TIMEOUT=30000                          # Limit czasu wykonania narzędzia MCP
MAX_MCP_OUTPUT_TOKENS=25000                     # Limit wyjścia MCP
SLASH_COMMAND_TOOL_CHAR_BUDGET=15000            # Limit kontekstu poleceń ukośnikowych

Sieć i proxy:

HTTP_PROXY=http://proxy:8080                    # Proxy HTTP
HTTPS_PROXY=https://proxy:8080                  # Proxy HTTPS
NO_PROXY=localhost,example.com                  # Pomija proxy dla wskazanych domen
CLAUDE_CODE_CLIENT_CERT=/path/to/cert           # Certyfikat mTLS
CLAUDE_CODE_CLIENT_KEY=/path/to/key             # Klucz prywatny mTLS
CLAUDE_CODE_CLIENT_KEY_PASSPHRASE=pass          # Hasło mTLS

Interfejs użytkownika i terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Nie aktualizuje tytułu terminala
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Pomija instalację rozszerzenia IDE
CLAUDE_CODE_SHELL=/bin/zsh                      # Nadpisanie wykrywania powłoki
USE_BUILTIN_RIPGREP=1                           # Używa wbudowanego ripgrep (domyślnie)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Niestandardowy katalog konfiguracji
IS_DEMO=1                                       # Ukrywa wrażliwe elementy interfejsu[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Wyłącza zadania w tle i Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Nadpisanie katalogu tymczasowego[^50]
CLAUDE_CODE_DISABLE_1M_CONTEXT=1               # Wyłącza okno kontekstu 1M (używa standardowego 200K)[^103]
CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=120000       # Limit czasu git dla marketplace pluginów (domyślnie 120 s, było 30 s)[^105]
CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS=1        # Usuwa wbudowane instrukcje commit/PR[^117]
CLAUDE_CODE_DISABLE_CRON=1                    # Zatrzymuje zaplanowane zadania cron w trakcie sesji[^121]
CLAUDE_CODE_SESSIONEND_HOOKS_TIMEOUT_MS=30000 # Limit czasu hooków SessionEnd (domyślna wartość zmienna)[^123]
CLAUDE_CODE_USE_POWERSHELL_TOOL=1             # Włącza narzędzie Windows PowerShell na Linux/macOS (wymaga pwsh w PATH; v2.1.111+)[^153]
CLAUDE_CODE_ENABLE_AWAY_SUMMARY=1             # Wymusza Session Recap przy wyłączonej telemetrii (v2.1.108+)[^153]
OTEL_LOG_RAW_API_BODIES=1                     # Emituje pełne ciała żądań/odpowiedzi API jako zdarzenia logów OTel (v2.1.111+)[^153]
TRACEPARENT=00-...                            # Rodzic W3C Trace Context (v2.1.110+, SDK/headless)[^153]
TRACESTATE=vendor=value                       # Stan W3C Trace Context (v2.1.110+, SDK/headless)[^153]

Eksportery OpenTelemetry + bramkowanie pól wrażliwych:¹⁶³

OTEL_LOGS_EXPORTER=none                       # Eksporter logów OTel (obsługuje 'none' do wyłączenia; v2.1.85 naprawiło awarię)
OTEL_METRICS_EXPORTER=none                    # Eksporter metryk OTel (obsługuje 'none'; v2.1.85 naprawiło awarię)
OTEL_TRACES_EXPORTER=none                     # Eksporter śladów OTel (obsługuje 'none'; v2.1.85 naprawiło awarię)
OTEL_LOG_TOOL_CONTENT=1                       # Włącza emisję zawartości narzędzi w spanach OTel (v2.1.101+, domyślnie wrażliwe)
OTEL_LOG_TOOL_DETAILS=1                       # Włącza tool_parameters w zdarzeniach tool_result OTel (v2.1.85+)
OTEL_LOG_USER_PROMPTS=1                       # Włącza emisję promptów użytkownika w śladach OTel (v2.1.101+, domyślnie wrażliwe)
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1    # Wyłącza pobieranie informacji o wydaniu (v2.0.17+); v2.1.110 zatrzymuje również automatyczne żądanie tytułu Haiku w trybie headless/SDK, gdy jest ustawione

Atrybuty spanów żądań LLM w v2.1.121+: stop_reason, gen_ai.response.finish_reasons oraz user_system_prompt są obecnie emitowane na spanach żądań LLM. user_system_prompt jest bramkowany przez OTEL_LOG_USER_PROMPTS=1, ponieważ może zawierać dane osobowe (PII).¹⁶¹

Zmiany na poziomie zdarzeń w v2.1.122+: Atrybuty numeryczne w zdarzeniach logów api_request i api_error są teraz emitowane jako liczby (wcześniej jako ciągi znaków) — naprawia to kolektory OTel poniżej w przepływie, które ściśle typowały schemat. Nowe zdarzenie logu claude_code.at_mention jest wyzwalane, gdy Claude Code rozpoznaje wzmiankę @.¹⁶¹

Kontrola API / modelu:¹⁶³

CLAUDE_CODE_EXTRA_BODY='{...}'                # Wstrzykuje dodatkowe pola ciała do wywołań API; v2.1.113 naprawia błędy 400 z output_config.effort w wywołaniach Vertex/subagent
CLAUDE_CODE_MAX_CONTEXT_TOKENS=200000         # Nadpisuje maksymalną liczbę tokenów kontekstu (zmienna istniejąca; v2.1.98 naprawia obsługę DISABLE_COMPACT przy obu ustawionych)
CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS=25000 # Nadpisuje domyślny limit tokenów dla operacji odczytu plików (v2.1.0+)
CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK=1   # Nie przełącza się na API bez strumieniowania przy błędach strumieniowania (v2.1.83+)
ANTHROPIC_BETAS=beta1,beta2                   # Włącza nagłówki beta API; v2.1.78 naprawia ciche ignorowanie w modelach Haiku
ANTHROPIC_SMALL_FAST_MODEL=arn:...            # Identyfikator szybkiego modelu (obsługa ARN Bedrock; v0.2.125 przestaje escapeować ukośniki w ARN)

Pluginy / MCP:¹⁶³

CLAUDE_CODE_PLUGIN_CACHE_DIR=~/.claude/plugins # Katalog pamięci podręcznej pluginów (v2.1.72 naprawia dosłowny katalog '~' w niektórych powłokach)
CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1 # Zachowuje pamięć podręczną marketplace pluginów przy niepowodzeniu git pull (przyjazne dla trybu offline; v2.1.90+)
CLAUDE_CODE_MCP_SERVER_NAME=server1           # Przekazywane do skryptów pomocniczych headersHelper MCP, dzięki czemu jeden helper może obsłużyć wiele serwerów (v2.1.85+)
CLAUDE_CODE_MCP_SERVER_URL=https://...        # Przekazywane do skryptów pomocniczych headersHelper MCP obok nazwy (v2.1.85+)

Powłoka / IDE:¹⁶³

CLAUDE_CODE_SHELL_PREFIX="time "              # Opakowuje każde polecenie powłoki wywoływane przez Claude prefiksem (v1.0.61+)
CLAUDE_CODE_GIT_BASH_PATH=C:\Program\ Files\Git\bin\bash.exe  # Niestandardowa ścieżka Git Bash w Windows (v2.1.98+)
CLAUDE_CODE_EXIT_AFTER_STOP_DELAY=60000       # SDK: zakończenie po N ms bezczynności (v2.0.35+)
CLAUDE_CODE_AUTO_CONNECT_IDE=false            # Wyłącza automatyczne łączenie z IDE (v1.0.61+)

Korporacja / uwierzytelnianie:¹⁶³

CLAUDE_CODE_PROXY_RESOLVES_HOSTS=1            # Włącza rozwiązywanie DNS po stronie proxy (v2.0.55 zmienia z domyślnie włączonego na opcjonalne)
CLAUDE_CODE_API_KEY_HELPER_TTL_MS=300000      # TTL dla dynamicznie generowanych kluczy API poprzez apiKeyHelper (odświeżanie apiKeyHelper dodano w v0.2.74 z domyślnym 5 min; zmienną środowiskową dodano w v0.2.117)

Zmienne dla Skills (v2.1.69+):

${CLAUDE_SKILL_DIR}                            # Samoodwołanie pozwalające skillom zlokalizować własny katalog[^117]

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

CLAUDE_CODE_ACCOUNT_UUID=uuid                  # Synchroniczne dostarczenie UUID konta dla wywołujących SDK
CLAUDE_CODE_USER_EMAIL=[email protected]        # Adres e-mail użytkownika dla wywołujących SDK
CLAUDE_CODE_ORGANIZATION_UUID=uuid             # UUID organizacji dla wywołujących SDK

Debugowanie:

ANTHROPIC_LOG=debug                             # Włącza rejestrowanie żądań API

Który model wybrać?

Wybór odpowiedniego modelu do każdego zadania znacząco wpływa zarówno na koszt, jak i jakość. Claude Code zapewnia elastyczne przełączanie modeli na wielu poziomach.

Dostępne modele

Opus 4.7 (16 kwietnia 2026): Aktualny model flagowy. Okno kontekstowe 1M tokenów w standardowej cenie — bez dopłaty za długi kontekst. Maksymalne wyjście 128K, wyłącznie myślenie adaptacyjne (rozszerzone myślenie zostało usunięte) oraz nowy poziom wysiłku xhigh zalecany jako punkt wyjścia dla obciążeń kodowania i agentowych.¹⁵² Wiarygodna granica wiedzy: styczeń 2026. Granica danych treningowych: styczeń 2026. ID modelu: claude-opus-4-7. Cennik odpowiada Opus 4.6 i wynosi 5/25 USD za MTok, z zapisem cache 5-min za 6,25 USD, zapisem cache 1-godz. za 10 USD oraz odczytem cache za 0,50 USD za MTok.¹⁵¹ Opus 4.7 rozwiązuje 3× więcej zadań produkcyjnych w SWE-Bench niż Opus 4.6, osiąga 70% w CursorBench (wobec 58% dla 4.6) i podnosi wskaźnik rozwiązań o 13% w wewnętrznym benchmarku kodowania Anthropic obejmującym 93 zadania.¹⁵¹ Wykorzystuje nowy tokenizer — można spodziewać się około 1×–1,35× liczby tokenów dla tego samego tekstu; warto zwiększyć margines max_tokens oraz progi kompakcji.¹⁵² Wizja obsługuje obrazy do 2 576 px / 3,75 MP z mapowaniem współrzędnych pikseli 1:1.¹⁵²

Benchmarki kodowania Opus 4.7 (kwiecień 2026):¹⁵⁸

Opus 4.7 prowadzi w SWE-bench Verified o 12,7 nad szeroko cytowaną podstawą GPT-5-Codex oraz w SWE-bench Pro o 6,6 nad GPT-5.4 (57,7%). W Terminal-Bench 2.0 GPT-5.3-Codex nadal wyprzedza GPT-5.4 (77,3% wobec 75,1%) i oba modele prowadzą nad Opus 4.7 (69,4%). Liderstwo w benchmarkach jest płynne; warto sprawdzać strony dostawców przed podjęciem decyzji obejmującej kilka kwartałów.

Domyślny model według planu (Claude Code):¹⁵⁴

Opus 4.7 wymaga Claude Code w wersji v2.1.111 lub nowszej; należy uruchomić claude update, aby zaktualizować.¹⁵⁴ Bedrock, Vertex i Foundry udostępniają Opus 4.7 poprzez jawne pełne nazwy modeli lub przypięcia ANTHROPIC_DEFAULT_OPUS_MODEL, a nie domyślnie przez alias opus.¹⁵⁴

Zmiany niekompatybilne w Messages API w Opus 4.7 (widoczne dla wywołującego):¹⁵²

• Parametr budget_tokens rozszerzonego myślenia został usunięty. Należy zamiast niego stosować thinking: {type: "adaptive"}. Myślenie adaptacyjne jest domyślnie wyłączone; żądania bez pola thinking działają bez myślenia.
• Ustawienie temperature, top_p lub top_k na wartość niedomyślną zwraca HTTP 400. Warto pominąć te parametry i sterować modelem za pomocą promptów.
• Treść myślenia jest domyślnie pomijana w odpowiedziach. Aby przywrócić widoczne rozumowanie, należy ustawić thinking.display: "summarized" (wymagane, jeśli produkt strumieniuje myślenie do użytkowników).

Budżety zadań (nagłówek beta task-budgets-2026-03-13) umożliwiają zasugerowanie modelowi docelowej liczby tokenów w całej pętli agentowej za pośrednictwem output_config.task_budget; minimum 20K tokenów.¹⁵²

Opus 4.6 (starsza wersja): Nadal dostępny jako claude-opus-4-6 z kontekstem 1M i maksymalnym wyjściem 128K. Warto rozważyć migrację do Opus 4.7 dla lepszego kodowania agentowego. Opus 4.6 pierwotnie ukazał się 5 lutego 2026.⁸⁶¹⁵¹ Od wersji v2.1.117 (22 kwietnia 2026) subskrybenci Pro i Max domyślnie korzystają z poziomu wysiłku high w Opus 4.6 i Sonnet 4.6 (poprzednio medium); Opus 4.7 pozostaje na xhigh. Ta zmiana przywróciła inteligencję po obniżeniu wysiłku z 4 marca → 7 kwietnia, udokumentowanym w postmortemie z 23 kwietnia.¹⁵⁹¹⁶⁰

Sonnet 4.6 (17 lutego 2026): Zrównoważony model; zastąpił Sonnet 4.5 jako domyślny w claude.ai i Claude Cowork.¹⁰⁰ Ten sam cennik co Sonnet 4.5 (3/15 USD za MTok). Ulepszona wydajność wyszukiwania agentowego przy mniejszym zużyciu tokenów. Obsługuje rozszerzone myślenie, myślenie adaptacyjne oraz okno kontekstowe 1M tokenów (beta). Maksymalne wyjście 64K (górna granica 128K w v2.1.77).¹²⁶ Granica wiedzy: sierpień 2025 (wiarygodna), styczeń 2026 (dane treningowe). ID modelu: claude-sonnet-4-6.

Claude Mythos Preview (7 kwietnia 2026): Model frontierowy w fazie podglądu badawczego, przeznaczony do defensywnej pracy w cyberbezpieczeństwie, oferowany w ramach Project Glasswing.¹⁴⁶ Tylko z zaproszeniem; nie jest ogólnie dostępny. Anthropic pozycjonuje Opus 4.7 jako celowo mniej zdolny niż Mythos w wymiarach cyber — kompromis bezpieczeństwa — i otworzył Cyber Verification Program pod adresem https://claude.com/form/cyber-use-case dla zweryfikowanych badaczy bezpieczeństwa potrzebujących podwyższonego dostępu.¹⁵³

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

Kiedy używać każdego modelu

Haiku: Można używać dla subagentów wykonujących eksplorację, prostych wyszukiwań plików, szybkich pytań. Jest ~5× tańszy niż Opus i odpowiada szybciej. Idealny do zadań w tle, gdzie nie jest potrzebne głębokie rozumowanie.

Sonnet: Koń pociągowy do codziennego rozwoju, gdy koszt ma znaczenie. Obsługuje większość zadań kodowania: implementację funkcji, naprawę błędów, pisanie testów, przegląd kodu. Sonnet 4.6 zapewnia ulepszone wyszukiwanie agentowe i lepszą efektywność tokenów w porównaniu z Sonnet 4.5, z obsługą myślenia adaptacyjnego i oknem kontekstowym 1M w standardowej cenie.¹⁰⁰ Od czasu Opus 4.7 (16 kwietnia 2026) Claude Code domyślnie używa Opus tylko w planach Max i Team Premium; konta Pro, Team Standard, Enterprise oraz API zachowują Sonnet 4.6 jako domyślny do czasu, aż Enterprise i API przejdą na Opus 4.7 23 kwietnia 2026.¹⁵⁴ Sonnet warto stosować, gdy potrzebne są tańsze tokeny, niższe opóźnienia lub ekonomika subagentów.

Opus: Flagowy poziom od 16 kwietnia 2026 i domyślny w planach Max i Team Premium.¹⁵¹¹⁵⁴ Droższe rozumowanie warto rezerwować tam, gdzie się opłaca: decyzje architektoniczne, trudne debugowanie, rozumienie złożonych systemów, analiza bezpieczeństwa, długoterminowa praca agentowa. Opus 4.7 rozwiązuje 3× więcej zadań produkcyjnych w SWE-Bench niż Opus 4.6, osiąga 70% w CursorBench (wobec 58%) i podnosi wskaźnik rozwiązań o 13% w wewnętrznym benchmarku kodowania obejmującym 93 zadania.¹⁵¹ Claude Code domyślnie ustawia poziom wysiłku xhigh dla Opus 4.7, regulowany przez /effort (v2.1.111+).¹⁵³¹⁵⁴ Auto Mode jest dostępny dla subskrybentów Max w Opus 4.7 poprzez Anthropic API bez konieczności użycia --enable-auto-mode; inne plany/dostawcy mają dostępność zależną od planu i kontrolowaną przez administratora.¹⁵³ Kontekst 1M w standardowej cenie — bez dopłaty za długi kontekst. Zmiany w zachowaniu warte poznania: Opus 4.7 bardziej dosłownie podąża za instrukcjami, kalibruje długość odpowiedzi do złożoności zadania, domyślnie uruchamia mniej subagentów oraz przyjmuje bardziej bezpośredni ton z mniejszą liczbą fraz potwierdzających. Jeśli prompty zawierają rusztowanie wymuszające komunikaty o postępach pośrednich lub zachowanie podwójnego sprawdzania, warto je usunąć.¹⁵²

Opusplan: Tryb hybrydowy używający Opus do planowania (gdzie jakość rozumowania ma największe znaczenie) i Sonnet do wykonania (gdzie liczy się szybkość). Doskonały do złożonego refaktoringu, gdy potrzebny jest najlepszy plan, ale nie jest wymagane rozumowanie poziomu Opus dla każdej pojedynczej edycji.

Przełączanie modeli

Podczas sesji:

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

Przy uruchomieniu:

claude --model opus

Przez zmienną środowiskową:

export ANTHROPIC_MODEL=opus

W settings.json:

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

Specyficznie 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.7 z kontekstem 1M

Lub w trakcie sesji:

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

Opus 4.7, Opus 4.6 i Sonnet 4.6 obejmują pełne okno kontekstowe 1M tokenów w standardowej cenie — bez dopłaty za długi kontekst.¹⁵⁵ Żądanie 900K tokenów jest rozliczane według tej samej stawki za token co żądanie 9K tokenów. Rabaty na buforowanie promptów i przetwarzanie wsadowe obowiązują w standardowych stawkach w całym oknie kontekstowym.

W subskrypcjach Max, Team i Enterprise Opus z kontekstem 1M jest dołączany automatycznie — przyrostek [1m] nie jest potrzebny (włączony domyślnie od v2.1.75, 13 marca 2026).¹²⁴¹⁵⁴ W Pro kontekst 1M jest dostępny przez dodatkowe użycie. Użytkownicy API i pay-as-you-go mają pełny dostęp do 1M w standardowych stawkach za token.¹⁵⁴

Aby wyłączyć warianty kontekstu 1M w wyborze modeli, należy ustawić CLAUDE_CODE_DISABLE_1M_CONTEXT=1.

Sprawdzanie aktualnego modelu

> /status

Polecenie pokazuje aktualny model, informacje o koncie, zastosowane ustawienia oraz inne stany sesji.

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

Tryb szybki (v2.1.36+)

Tryb szybki zapewnia znacznie szybsze wyjście z tego samego modelu; nie przełącza na tańszy model. Można go włączać podczas sesji za pomocą /fast.⁹³

> /fast            # Włącz/wyłącz tryb szybki

Cennik (tryb szybki Opus 4.6):

Tryb szybki jest podglądem badawczym, dostępny tylko dla Opus 4.6 i zapewnia ~2,5× szybsze wyjście przy 6× cenie bazowej.¹⁵⁶ Włączenie /fast automatycznie przełącza sesję na Opus 4.6, jeśli używany był inny model; wyłączenie /fast pozostawia użytkownika na Opus 4.6 do czasu przełączenia przez /model. Tryb szybki nie jest dostępny w Opus 4.7, Sonnet, Haiku ani przez Bedrock/Vertex/Foundry. Wymaga włączenia dodatkowego użycia, a w przypadku Team/Enterprise — aktywacji przez administratora.

Kiedy używać trybu szybkiego: - Szybka iteracja drobnych zmian, gdy wąskim gardłem są opóźnienia - Generowanie testów, szablonów lub powtarzalnego kodu, gdy szybkość liczy się bardziej niż koszt - Sekwencyjna praca nad listą podobnych zadań

Kiedy NIE używać trybu szybkiego: - Długotrwałe zadania agentowe (koszt szybko narasta przy stawkach 6×) - Praca subagentów w tle (nikt nie czeka na wyjście) - Sesje z ograniczonym budżetem

Tryb szybki Opus 4.6 obejmuje pełne okno kontekstowe 1M (v2.1.50+). Cennik trybu szybkiego jest płaski w całym kontekście 1M — bez dodatkowej dopłaty za długi kontekst.¹⁰³¹⁵⁶

Wskazówka eksperta: Tryb szybki nie łączy się z opusplan (opusplan już miesza Opus i Sonnet; tryb szybki wpływa wyłącznie na Opus 4.6). Tryb szybki warto stosować bezpośrednio, gdy opóźnienia mają większe znaczenie niż koszt, oraz wyłączać go przy pracy autonomicznej lub wsadowej. /fast wymaga dodatkowego użycia; administratorzy Team/Enterprise mogą najpierw musieć go włączyć (poprawka v2.1.37).⁹³¹⁵⁶

Kontrola wysiłku (v2.1.111+, Opus 4.7)

Opus 4.7 wprowadza nowe pokrętło wysiłku, które dostraja kompromis między szybkością a inteligencją. Można użyć /effort podczas sesji:

> /effort              # otwiera interaktywny suwak (strzałki + Enter)
> /effort xhigh        # ustawienie bezpośrednie

Claude Code domyślnie ustawia teraz wysiłek xhigh dla Opus 4.7. xhigh jest dostępny tylko dla Opus 4.7 — inne modele wracają do high. Claude Managed Agents obsługuje wysiłek automatycznie; parametr wysiłku jest koncepcją Messages API.¹⁵²¹⁵³

Auto Mode w planie Max (v2.1.111+)

Auto Mode — bezpieczniejszy zamiennik dla --dangerously-skip-permissions — jest dostępny dla subskrybentów Max w Opus 4.7 przez Anthropic API bez --enable-auto-mode.¹⁵³ Klasyfikator oparty na Sonnet 4.6 sprawdza każdą akcję przed wykonaniem, weryfikując zgodność intencji i bezpieczeństwo. Uwaga (v2.1.111+): flaga --enable-auto-mode została usunięta; sesję w Auto Mode należy uruchamiać poleceniem --permission-mode auto. Auto Mode nie jest dostępny w Pro; zgodnie z dokumentacją trybów uprawnień Anthropic jest obecnie dostępny tylko bezpośrednio przez Anthropic-API — Bedrock, Vertex i Foundry nie są jeszcze obsługiwane.

Niestandardowe reguły bez utraty domyślnych (v2.1.118+). Wcześniejsze wersje sprawiały, że autoMode.allow, autoMode.soft_deny i autoMode.environment działały na zasadzie albo-albo: zdefiniowanie własnej listy oznaczało utratę wbudowanych reguł bezpieczeństwa. Wartownik $defaults rozwiązuje ten problem — rozwija się on inline do wbudowanej listy dokładnie w miejscu, w którym został umieszczony, dzięki czemu można nakładać reguły niestandardowe wokół niej:¹⁵⁹

// .claude/settings.json
{
  "autoMode": {
    "allow": [
      "Bash(npm test:*)",        // własne dodatki, dodane na początku
      "$defaults",                // wbudowana lista allow wstawiona tutaj
      "Bash(git push:origin/feature/*)"  // dodane na końcu
    ]
  }
}

Opcja „Nie pytaj ponownie” (v2.1.118+). Monit z opcją włączenia Auto Mode oferuje teraz opcję „Nie pytaj ponownie”, dzięki czemu częsci użytkownicy mogą wyciszyć wyjaśnienie bez skryptowego ustawiania flagi.¹⁵⁹

Nowe polecenia w v2.1.105–v2.1.114¹⁵³¹⁵⁷

Podsumowanie sesji (v2.1.108+)

Nowa funkcja na poziomie sesji, która udostępnia kontekst po powrocie do wstrzymanej sesji. Włączona domyślnie i wyłączalna przez /config lub CLAUDE_CODE_ENABLE_AWAY_SUMMARY=0. Model może również wywoływać wbudowane polecenia ukośnikowe (/init, /review, /security-review) za pomocą narzędzia Skill — rozszerza wzorzec subagent/skill.¹⁵³

Powiadomienia push (v2.1.110+)

Gdy Remote Control jest skonfigurowany z włączoną opcją „Push, gdy Claude zdecyduje”, Claude może teraz wysyłać mobilne powiadomienia push według własnego uznania za pomocą nowego narzędzia push-notification. Współpracuje z istniejącą powierzchnią mobilną/webową Remote Control.¹⁵³ /context, /exit oraz /reload-plugins działają teraz również z klientów Remote Control.

Narzędzie Windows PowerShell (v2.1.111+, wdrażanie)

Claude Code wdraża natywne narzędzie Windows PowerShell. W systemach Linux/macOS można je włączyć przez CLAUDE_CODE_USE_POWERSHELL_TOOL=1 (wymaga pwsh w PATH). W systemie Windows ta sama zmienna kontroluje opt-in/opt-out podczas wdrażania.¹⁵³

Automatyczne zatwierdzanie w trybie uprawnień (v2.1.119+). Polecenia narzędzia PowerShell mogą teraz otrzymywać automatyczne zatwierdzenie w trybie uprawnień w taki sam sposób jak polecenia Bash. Reguły allow takie jak PowerShell(Get-*:*) oraz istniejąca składnia wzorców pomijają teraz monit dla operacji tylko do odczytu, dopasowując ergonomię operatorską, którą zespoły uzyskują już w systemach Linux/macOS.¹⁵⁹

Redukcja uprawnień: Bash tylko do odczytu (v2.1.111+)

Wzorce Bash tylko do odczytu z argumentami glob (np. ls *.ts, cat src/*.md) oraz polecenia rozpoczynające się od cd <project-dir> && nie wywołują już monitu o uprawnienia.¹⁵³ W połączeniu z /less-permission-prompts można spodziewać się znacznie mniejszej liczby przerwań w codziennych przepływach pracy.

Śledzenie rozproszone (v2.1.110+)

SDK i sesje headless odczytują teraz TRACEPARENT i TRACESTATE ze środowiska, łącząc uruchomienia Claude Code z trasami rozproszonymi. Można je sparować z OTEL_LOG_RAW_API_BODIES=1 (v2.1.111+) w celu emisji pełnych treści żądań/odpowiedzi API jako zdarzeń logu OpenTelemetry do debugowania.¹⁵³

Dystrybucja natywnych binariów (v2.1.113+)¹⁵⁷

v2.1.113 zmienia sposób uruchamiania CLI: claude uruchamia teraz natywny plik binarny Claude Code poprzez opcjonalną zależność dla danej platformy zamiast uruchamiać dołączony JavaScript. Polecenia instalacji i aktualizacji pozostają niezmienione, a zespoły nie muszą zmieniać skryptów wdrożeniowych.

Skróty edytora promptów (v2.1.113+)¹⁵⁷

Edytor promptów zyskuje nawigację w stylu readline w wprowadzaniu wieloliniowym oraz przewijanie pełnoekranowego widoku:

Są one domyślnie włączone. Konfiguracja klawiszologii nie jest wymagana.

Limit czasu zatrzymania subagenta (v2.1.113+)¹⁵⁷

Subagenci, którzy zatrzymują się w trakcie strumieniowania, kończą teraz pracę z czytelnym błędem po 10 minutach, zamiast cicho zawisnąć. Można sparować z CLAUDE_STREAM_IDLE_TIMEOUT_MS (v2.1.84+) w celu szerszego pokrycia zacinających się procesów na strumieniujących API.

Poprawka stabilności v2.1.114¹⁵⁷

v2.1.114 (18 kwietnia 2026) wprowadza pojedynczą poprawkę: dialog uprawnień mógł ulec awarii, gdy współpracownik z agent-teams żądał uprawnień do narzędzia. Należy zaktualizować, jeśli używa się Agent Teams.

Ile kosztuje Claude Code?

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

Wyświetlanie 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

Użytkownicy subskrypcji widzą w /cost podział według modelu i trafień w pamięci podręcznej, pokazujący dokładnie, które modele zużyły tokeny i ile zostało obsłużone z cache (v2.1.92+).¹⁴⁴

Plany subskrypcji

Limity stawek (sierpień 2025): Anthropic wprowadził tygodniowe limity stawek dla subskrybentów płatnych planów. Subskrybenci Max mogą nabyć dodatkowe wykorzystanie ponad limit stawek po standardowych cenach API.²¹

Ceny tokenów API (kwiecień 2026)¹¹⁵¹

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

Ceny za kontekst 1M (kwiecień 2026): Opus 4.7, Opus 4.6, Sonnet 4.6 oraz Mythos Preview obejmują 1M w standardowych stawkach za MTok — bez dopłaty za długi kontekst.¹⁵⁵ Jest to niedawna konsolidacja; wcześniejsze wytyczne dotyczące Opus 4.6 lub Sonnet 4.6 naliczających 2× wejście / 1,5× wyjście powyżej 200K tokenów wejściowych są już nieaktualne. Starsze modele Opus 4.5 i wcześniejsze zachowują swoje pierwotne struktury cenowe.

Ceny rezydencji danych: Określenie wnioskowania wyłącznie w USA za pomocą inference_geo dodaje mnożnik 1,1× do wszystkich cen tokenów, w tym odczytów i zapisów w pamięci podręcznej (modele Opus 4.6+).¹⁵⁵

Prompt caching znacząco redukuje koszty powtarzających się danych wejściowych: zapisy w pamięci podręcznej kosztują 1,25× stawki bazowej (cache 5-minutowy) lub 2× (cache 1-godzinny), ale odczyty z pamięci podręcznej kosztują jedynie 0,1×, co daje oszczędność 90%. W systemach RAG i asystentach kodu z powtarzającym się kontekstem caching może obniżyć koszty o 88-95%.

Batch API oferuje 50% zniżki z czasem realizacji 24 godzin dla zadań niepilnych, takich jak nocne zestawy testów.

Polityka dotycząca wielu kont⁵⁹

Czy można posiadać wiele kont Claude? Tak, w przypadku uzasadnionych scenariuszy. Anthropic wyraźnie dopuszcza wiele kont, gdy służą one odrębnym celom.

Co jest dozwolone:

Limity techniczne: - Do 3 kont można zweryfikować za pomocą tego samego numeru telefonu - Wiele płatnych subskrypcji z tego samego adresu IP/sieci jest jawnie obsługiwane - Konta są całkowicie oddzielone; brak możliwości przenoszenia czatu lub projektu między nimi

Co jest zabronione (zgodnie z Polityką użytkowania): - Tworzenie kont w celu obejścia blokady po nałożeniu bana - Koordynowanie złośliwej działalności między kontami w celu uniknięcia wykrycia - Używanie wielu kont w celu obchodzenia limitów stawek lub kredytów bezpłatnego planu

Uwaga z praktyki: W styczniu 2026 roku zaawansowany użytkownik Jeffrey Emanuel (@doodlestein) miał 22 konta Max automatycznie oflagowane i tymczasowo zablokowane. Pracownik Anthropic, Thariq (@trq212), rozwiązał sprawę w ciągu 4 godzin po potwierdzeniu uzasadnionego wykorzystania. Jeśli korzysta Pan/Pani intensywnie z Claude Code zarówno do pracy, jak i projektów osobistych na wielu kontach, to właśnie do tego usługa została zaprojektowana, ale nie należy próbować oszukiwać systemu.

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

Czynniki wpływające na koszty

Realne przykłady kosztów

Wskazówka oszczędzająca koszty: 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

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

Ukryte opłaty za narzędzia

Poza cenami za token, niektóre narzędzia wiążą się z odrębnymi opłatami:¹⁶

Wartości te sumują się w pętlach agentów. 100-iteracyjny cykl debugowania z Bash kosztuje dodatkowo ~24 500 tokenów wejściowych w samym narzucie.

Strategie oszczędzania kosztów

1. Warto używać Haiku do subagentów: Większość eksploracji nie wymaga Sonnet
2. Należy włączyć prompt caching: Domyślnie, ale warto zweryfikować, czy nie jest wyłączony
3. Ustawić maksymalną liczbę tur: claude --max-turns 5 zapobiega niekontrolowanym konwersacjom
4. Używać trybu planowania do eksploracji: Brak wykonywania = brak przypadkowych kosztownych operacji
5. Proaktywnie kompaktować: Mniejszy kontekst = mniej tokenów
6. Ograniczać wyjście: export CLAUDE_CODE_MAX_OUTPUT_TOKENS=2000
7. Batch API do zadań niepilnych: 50% zniżki zarówno na tokeny wejściowe, jak i wyjściowe

Monitorowanie wykorzystania

• Konsola Claude: platform.claude.com (wymaga roli Admin lub Billing)
• Limity przestrzeni roboczej: Ustawianie limitów wydatków dla poszczególnych przestrzeni roboczych
• Bedrock/Vertex: Korzystanie z natywnego monitorowania kosztów chmury
• LiteLLM: Do szczegółowego śledzenia na użytkownika z dostawcami zewnętrznymi

Wykorzystanie tokenów w tle

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

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

Claude Code Analytics API (Team/Enterprise)⁵³

Programistyczny dostęp do analityki wykorzystania Claude Code w Pana/Pani organizacji oraz 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"

Przypadki użycia: - Analiza produktywności deweloperów (sesje, commity, PR) - Metryki użycia narzędzi (wskaźniki akceptacji/odrzucenia dla Edit, Write itp.) - Śledzenie kosztów i ich alokacja w zespołach - Uzasadnienie ROI dla narzędzi kodowania AI

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

Ramy decyzyjne

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

Którego modelu należy 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.7 (domyślnie xhigh effort)
                  │         Koszt: ~$2.00/zadanie
                  │         Jakość: Najwyższa (1M kontekstu w standardowej cenie, adaptacyjne rozumowanie)
                  │
                  └── NIE → Użyj Sonnet
                           Koszt: ~$0.75/zadanie
                           Równowaga: Najlepsza, gdy koszt ma znaczenie

Zasada praktyczna: Opus 4.7 jest domyślny dla Max oraz Team Premium. W planach Pro/Team Standard/Enterprise/API domyślny jest Sonnet 4.6 (Enterprise + Anthropic API przechodzą na Opus 4.7 23 kwietnia 2026).¹⁵⁴ Warto zejść do Haiku dla subagentów. Należy eskalować do Opus, gdy odpowiedź Sonnet wydaje się powierzchowna. Dzięki agent teams (v2.1.32+) Opus może koordynować wiele agentów pracujących równolegle nad różnymi podzadaniami.⁸⁶

Command, Skill, Subagent czy Agent Team?

Czy chcesz mieć jawną kontrolę nad tym, kiedy się uruchomi?
│
├── TAK → Użyj Slash Command
│         Przykład: /deploy, /test, /security-review
│         Ty go wywołujesz. Ty kontrolujesz moment.
│
└── NIE → Czy ekspertyza ma się stosować automatycznie w oparciu o kontekst?
         │
         ├── TAK → Użyj Skill
         │         Przykład: wzorce bezpieczeństwa, reguły domenowe, standardy kodu
         │         Claude rozpoznaje kontekst i stosuje ekspertyzę.
         │
         └── NIE → Czy praca wymaga odizolowanego kontekstu?
                  │
                  ├── TAK → Czy jest jedno podzadanie, czy wiele równoległych?
                  │         │
                  │         ├── JEDNO → Użyj Subagent (narzędzie Task)
                  │         │         Przykład: głęboka eksploracja, analiza równoległa
                  │         │         Zapobiega rozrostowi kontekstu w głównej rozmowie.
                  │         │
                  │         └── WIELE → Użyj Agent Team (v2.1.32+)
                  │                   Przykład: 5 agentów przegląda jednocześnie różne moduły
                  │                   Opus koordynuje; każdy agent pracuje niezależnie.
                  │
                  └── NIE → Po prostu zaprompruj bezpośrednio
                           Nie wszystko wymaga abstrakcji.

Hook czy prompt?

Czy działanie MUSI zawsze nastąpić, niezależnie od oceny Claude?
│
├── TAK → Użyj Hook (deterministyczny)
│         Przykłady:
│         - Formatowanie kodu po każdej edycji
│         - Logowanie wszystkich poleceń bash
│         - Blokowanie dostępu do plików .env
│         Claude nie może pominąć, zapomnieć ani zdecydować inaczej.
│
└── NIE → Użyj Prompt (probabilistyczny)
         Przykłady:
         - „Rozważ dodanie testów"
         - „Pomyśl o przypadkach brzegowych"
         - „Przejrzyj pod kątem bezpieczeństwa, jeśli jest to istotne"
         Claude decyduje na podstawie kontekstu.

Kiedy używać rozszerzonego myślenia (extended thinking)?

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

Przełączanie za pomocą Alt+T w trakcie sesji. Wyższe budżety myślenia kosztują więcej; warto zacząć od minimum i zwiększać tylko wtedy, gdy odpowiedzi wydają się pospieszne.

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

Który sposób wykonania?

Gdzie powinna odbyć się ta praca?
│
├── Wymaga TWOICH lokalnych plików i narzędzi
│   │
│   ├── Praca interaktywna, iteracyjna → Główna sesja REPL
│   ├── Jednorazowe zadanie skryptowe → claude -p "prompt" (tryb print)
│   ├── Automatyzacja CI/CD → claude -p --json (nieinteraktywny + ustrukturyzowane wyjście)
│   └── Równoległe zadania izolowane → Subagenty przez narzędzie Task
│
├── Wymaga CUDZEGO środowiska
│   │
│   └── Zdalna baza kodu 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, subagenty czy 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 dzielą dostęp do repo.
│         │         │         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 subagentów
│                  Wyniki jednego zasilają następny.
│                  Przykład: „Explore → Plan → Implement"
│
└── NIE → Użyj pojedynczego subagenta lub głównej sesji REPL

Który typ hooka?

Jaki rodzaj automatyzacji jest potrzebny?
│
├── Uruchomienie polecenia 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"
│
├── Modyfikacja system promptu Claude w oparciu o kontekst?
│   │
│   └── 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..."
│
└── Niech Claude dokona oceny, zanim przejdzie dalej?
    │
    └── 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
│         Dobry do: szybkich pytań, prostych edycji, wyjaśnień kodu,
│                   wyszukiwania plików, zadań formatujących
│
└── NIE → Pozostań w trybie normalnym
         Dobry do: decyzji architektonicznych, złożonego debugowania,
                   przeglądów bezpieczeństwa, refaktoringów wielu plików,
                   wszystkiego, co wymaga 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 precyzyjną kontrolę nad tym, jakie operacje mogą być wykonywane. Jego zrozumienie ma kluczowe znaczenie zarówno dla bezpieczeństwa, jak i wydajności pracy. Zobacz także Wdrożenie korporacyjne — opisuje zarządzane ustawienia, które wymuszają uprawnienia w całej organizacji.

Poziomy uprawnień

Narzędzia tylko do odczytu (zatwierdzane automatycznie): - Read — odczyt zawartości plików - Glob — wyszukiwanie plików według wzorca - Grep — przeszukiwanie zawartości plików - WebSearch — wyszukiwanie w sieci - LSP — inteligencja kodu (przejście do definicji, wyszukiwanie odniesień, 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: skok do miejsca, gdzie symbol jest zdefiniowany - Wyszukiwanie odniesień: lista wszystkich użyć symbolu w bazie kodu - Dokumentacja po najechaniu: informacje o typach i dokumentacja dla dowolnego symbolu - Działa z TypeScript, Python, Go, Rust oraz innymi językami obsługującymi LSP - Wymaga dostępności serwera języka (zazwyczaj instalowanego razem z używanym łańcuchem narzędzi)

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

Przy pierwszym uruchomieniu narzędzia modyfikującego Claude Code prosi o zatwierdzenie. Zatwierdzenia są zachowywane przez całą sesję, o ile nie skonfigurowano inaczej.

Tryby uprawnień

Tryb Auto (v2.1.85+): Bezpieczniejszy zamiennik dla --dangerously-skip-permissions. Osobny model klasyfikujący (Sonnet 4.6) weryfikuje każde działanie przed wykonaniem, sprawdzając, czy odpowiada intencji użytkownika i jest bezpieczne.¹³¹

Sposób działania: - Działania tylko do odczytu oraz edycje plików w katalogu roboczym są zatwierdzane automatycznie - Niestandardowe reguły allow/deny mają pierwszeństwo - Wszystko inne trafia do klasyfikatora w celu oceny - W przypadku zablokowania Claude automatycznie próbuje alternatywnego podejścia

Domyślnie blokowane: curl | bash, force-push do main, wdrożenia/migracje produkcyjne, masowe usuwanie w chmurze, zmiany IAM/uprawnień, wysyłanie wrażliwych danych na zewnątrz.¹³²

Bezpiecznik (circuit breaker): 3 kolejne blokady lub 20 łącznie w jednej sesji wstrzymuje pracę i wraca do ręcznych pytań.¹³²

# Enable at startup
claude --enable-auto-mode

# Or cycle into it during a session
Shift+Tab  # Cycles through: default → acceptEdits → auto → plan

Dostępność: najpierw użytkownicy planu Team, następnie Enterprise oraz API. Wymaga modelu Sonnet 4.6 lub Opus 4.6.¹³¹

Tryb YOLO (v2.0.68+): W celu w pełni autonomicznej pracy bez jakiegokolwiek klasyfikatora bezpieczeństwa należy użyć flagi --dangerously-skip-permissions. Flaga ta odpowiada „tak” na wszystko: edycje plików, polecenia bash, wszystkie wywołania narzędzi. Słowo „dangerous” jest celowe. W większości zastosowań rekomendowaną alternatywą jest tryb Auto.⁶¹

claude --dangerously-skip-permissions

Ustawienie trybu poprzez CLI:

claude --permission-mode auto  # or acceptEdits, plan, bypassPermissions

Przełączanie podczas sesji:

Shift+Tab  # Cycles through modes

W settings.json:

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

Składnia reguł uprawnień

Precyzyjne reguły kontrolują konkretne operacje. Reguły są oceniane w kolejności: pierwsze dopasowanie wygrywa.

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 realizuje dopasowanie po prefiksie: Bash(npm run test:*) zezwala na npm run test, npm run test:unit oraz npm run test:integration.

Istotne ograniczenie: Wzorce bash dopasowują wyłącznie prefiksy, a nie wyrażenia regularne. Wzorzec taki jak Bash(curl http:*) nie dopasuje curl -X GET http://..., ponieważ opcje znajdują się przed adresem URL. Aby niezawodnie zablokować polecenie, należy odmówić 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ędne wobec katalogu roboczego - Absolutne wobec pliku ustawień: Edit(/build/**) — względne wobec lokalizacji pliku ustawień - Prawdziwie absolutne: 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 symboli wieloznacznych mcp__server__* umożliwia zezwolenie lub odmowę dla wszystkich narzędzi z określonego serwera MCP.³⁹ Składnia ta 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

Można rozszerzyć dostęp Claude poza bieżący projekt:

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

Dodatkowe katalogi są niezbędne dla monorepo lub gdy Claude musi odwoływać się do kodu w katalogach równoległych.

Tryb sandbox

Włączenie izolacji systemu plików oraz sieci:

> /sandbox

Lub konfiguracja w ustawieniach:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["git", "docker"],
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"],
      "allowLocalBinding": true,
      "deniedDomains": ["pastebin.com", "transfer.sh", "0x0.st"]
    }
  }
}

W trybie sandbox: - Dostęp do systemu plików ograniczony do katalogu projektu - Dostęp do sieci kontrolowany - Określone polecenia wyłączone z ograniczeń sandboxa - Polecenia bash zatwierdzane automatycznie, jeśli autoAllowBashIfSandboxed ma wartość true

Wskazówka eksperta: Tryb sandbox świetnie sprawdza się przy uruchamianiu Claude na niezaufanych bazach kodu. Warto go włączyć przy eksplorowaniu nieznanych projektów lub gdy potrzebna jest dodatkowa warstwa ochrony. Wewnętrzne testy Anthropic wykazały, że sandboxing redukuje liczbę pytań o uprawnienia o 84%.⁴⁵ Sandbox wykorzystuje prymitywy na poziomie systemu operacyjnego (seatbelt w macOS, bubblewrap w Linuksie) do izolacji systemu plików i sieci, dzięki czemu nawet udany prompt injection jest w pełni zamknięty. Anthropic udostępniła środowisko uruchomieniowe sandboxa jako open source dla zespołów budujących własnych agentów.⁸⁹

Uwagi dotyczące bezpieczeństwa (v2.1.34+): Polecenia wyłączone z sandboxa za pomocą sandbox.excludedCommands lub dangerouslyDisableSandbox mogły wcześniej omijać regułę pytania o uprawnienia bash, gdy włączone było autoAllowBashIfSandboxed; problem ten został naprawiony w v2.1.34.⁹⁴ Od wersji v2.1.38 zapisy do .claude/skills są blokowane w trybie sandbox, co zapobiega modyfikowaniu definicji skills przez prompt injection.⁹⁵ v2.1.77 dodaje ustawienie systemu plików sandboxa allowRead, które ponownie zezwala na dostęp do odczytu w obrębie regionów denyRead — przydatne, gdy chce się zablokować większość drzewa katalogów, ale dodać do białej listy konkretne podkatalogi.¹²⁶

Wyłączenie konfiguracji agentów .claude/ (v2.1.121+): --dangerously-skip-permissions nie pyta już o zapisy do .claude/skills/, .claude/agents/ oraz .claude/commands/.¹⁶¹

Wzmocnienie bezpieczeństwa w v2.1.113:¹⁵⁷

• sandbox.network.deniedDomains blokuje konkretne hosty nawet wtedy, gdy szerszy symbol wieloznaczny allowedDomains w innym przypadku by je dopuścił. Listę blokowania można wykorzystać do odcięcia pastebinów, serwisów do udostępniania plików lub znanych szkodliwych hostów bez przepisywania całej polityki zezwalania.
• Reguły deny dla poleceń-wrapperów. Reguły deny dla bash dopasowują teraz polecenia opakowane w env, sudo, watch, ionice, setsid oraz podobne wrappery wykonawcze. Reguły takie jak Bash(rm:*) wychwytują obecnie env rm -rf, sudo rm -rf oraz pokrewne wzorce omijania.
• Reguły allow Bash(find:*) nie zatwierdzają już automatycznie find -exec ani find -delete. Te flagi wykonują polecenia oraz usuwają pliki, dlatego Claude Code kieruje je przez standardową ścieżkę uprawnień.
• Ochrona przed usuwaniem w macOS. Reguły allow Bash(rm:*) traktują obecnie /private/etc, /private/var, /private/tmp oraz /private/home jako niebezpieczne cele usuwania. /var, /etc oraz /tmp są dowiązaniami symbolicznymi do /private/, więc poprzedni kształt reguły pomijał te kanoniczne cele.

Jak działają hooks?

Hooks wykonują deterministyczne polecenia powłoki w określonych punktach przepływu pracy Claude Code. W przeciwieństwie do instruowania Claude poprzez prompt, aby wykonał określone akcje, hooks gwarantują wykonanie niezależnie od zachowania modelu. Są niezbędne do egzekwowania standardów zespołu i automatyzacji powtarzalnych zadań. Proszę zobaczyć Decision Frameworks — drzewo decyzyjne „Który typ hooka?” obejmujące hooks typu command, prompt i agent.

Dlaczego hooks zamiast promptów: Mówienie Claude „zawsze uruchamiaj Prettier po edycji plików” działa czasami. Niemniej Claude może zapomnieć, dać priorytet szybkości lub zdecydować, że zmiana jest „zbyt drobna”. Hooks gwarantują wykonanie: każdy Edit lub Write uruchamia formatter — za każdym razem, bez wyjątków. W kwestii zgodności, bezpieczeństwa i standardów zespołu deterministyczne podejście bije probabilistyczne.⁷

Dostępne zdarzenia

Konfiguracja hooków

Proszę zdefiniować hooks w settings.json lub w 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 uruchamiają dany hook:

{"matcher": "*"}              // Dopasowanie do wszystkich narzędzi
{"matcher": "Bash"}           // Dopasowanie tylko do Bash
{"matcher": "Edit|Write"}     // Dopasowanie do Edit lub Write
{"matcher": "mcp__github"}    // Dopasowanie do narzędzi serwera MCP
{"matcher": ""}               // Dopasowanie do zdarzeń bez narzędzi (jak UserPromptSubmit)

Protokół wejścia/wyjścia hooków

Hooks otrzymują JSON na stdin:

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

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

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 transkryptu:

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

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

Aby uzyskać zaawansowaną kontrolę, 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 dla bogatszej kontroli: trzy wyniki (allow/deny/ask) plus możliwość modyfikowania danych wejściowych narzędzia i wstrzykiwania kontekstu:⁹⁶

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

Uwaga: Pola decision i reason na najwyższym poziomie są przestarzałe dla PreToolUse. Proszę zamiast tego używać hookSpecificOutput.permissionDecision i hookSpecificOutput.permissionDecisionReason. Pozostałe zdarzenia (PostToolUse, Stop itd.) nadal używają decision na najwyższym poziomie.⁹⁶

Tytuł sesji UserPromptSubmit (v2.1.94+): Hooks UserPromptSubmit mogą ustawić tytuł sesji za pomocą hookSpecificOutput.sessionTitle.¹⁴⁷

Hooks asynchroniczne (styczeń 2026)

Hooks mogą teraz działać w tle bez blokowania wykonania Claude Code. Proszę dodać async: true do swojej konfiguracji hooka:⁸⁸

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

Kiedy używać hooków asynchronicznych: - 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ć hooków asynchronicznych: - Formatowanie (musi się zakończyć przed kolejną edycją) - Walidacja (musi blokować przy niepowodzeniu) - Każdy hook, który musi modyfikować dane wejściowe/wyjściowe narzędzia

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

Poza hookami opartymi na poleceniach powłoki (type: "command"), Claude Code obsługuje dwa typy hooków zasilane LLM, które oceniają warunki przy użyciu rozumowania AI zamiast skryptów.⁹⁶

Prompt hooks (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
          }
        ]
      }
    ]
  }
}

HTTP hooks (type: "http") wysyłają JSON wejście zdarzenia jako żądanie POST pod adres URL i otrzymują z powrotem JSON. Proszę używać ich 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"]
          }
        ]
      }
    ]
  }
}

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

Agent hooks (type: "agent") tworzą subagenta z dostępem do narzędzi (Read, Grep, Glob) do wieloturowej weryfikacji. Proszę używać ich, gdy sprawdzenie wymaga inspekcji rzeczywistych plików lub wyniku testów:

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

Proszę używać $ARGUMENTS jako symbolu zastępczego dla wejścia JSON hooka. 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 hooków typu prompt/agent.

Hooks narzędzi MCP (v2.1.118+)

Hooks mogą teraz wywoływać narzędzie MCP bezpośrednio przez type: "mcp_tool", omijając konieczność opakowywania podprocesu Bash, który wywołuje serwer.¹⁵⁹

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "mcp_tool",
            "server": "linear",
            "tool": "create_comment",
            "input": {"issue_id": "ENG-123", "body": "Auto-updated by Claude Code"}
          }
        ]
      }
    ]
  }
}

To dobrze współgra z serwerami MCP, które użytkownicy już skonfigurowali: każde narzędzie dostępne z /mcp staje się wywoływalne z poziomu hooków.

duration_ms w hookach PostToolUse (v2.1.119+)

Wejścia hooków PostToolUse i PostToolUseFailure zawierają teraz duration_ms — czas wykonania narzędzia z wyłączeniem promptów uprawnień i hooków PreToolUse.¹⁵⁹ Przydatne do wykrywania powolnych narzędzi, dzienników audytu i metryk opóźnień per narzędzie:

# Stderr-flagged warning when an Edit takes more than 10 seconds
DUR=$(jq -r '.duration_ms')
if [ "$DUR" -gt 10000 ]; then
  echo "[slow-edit] ${DUR}ms — investigate $TOOL_INPUT_FILE_PATH" >&2
fi

updatedToolOutput dla wszystkich narzędzi (v2.1.121+)

W wersji v2.1.118 hooks narzędzi MCP zyskały możliwość zastępowania wyniku narzędzia za pomocą hookSpecificOutput.updatedToolOutput. Od wersji v2.1.121 to samo pole działa dla każdego hooka PostToolUse — narzędzi wbudowanych (Bash, Read, Edit, Glob, Grep itd.), narzędzi subagentów oraz narzędzi MCP. Przypadki użycia: redagowanie wrażliwej zawartości z wyniku dowolnego narzędzia, normalizacja struktury dla późniejszych konsumentów, wstrzykiwanie metadanych, zanim agent odczyta wynik.¹⁶¹

Zmienne środowiskowe hooków

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

Utrwalenie 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 HTTP hooków (v2.1.51+): HTTP hooks, które interpolują zmienne środowiskowe do nagłówków, wymagają teraz jawnej listy allowedEnvVars. Zapobiega to dowolnej eksfiltracji zmiennych środowiskowych przez wartości nagłówków. HTTP hooks są również routowane przez sandbox network proxy, gdy sandboxing jest włączony, egzekwując listę dozwolonych domen. HTTP hooks 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 obszaru roboczego dla hooków (v2.1.51+): Polecenia hooków statusLine i fileSuggestion wymagają teraz akceptacji zaufania obszaru roboczego przed wykonaniem w trybie interaktywnym, zamykając potencjalny wektor bezpieczeństwa.¹⁰⁵

Praktyczne przykłady hooków

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 hooków

Proszę włączyć tryb debug, aby rozwiązywać problemy z hookami:

claude --debug

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

Wyświetlanie źródła hooka (v2.1.75+): Gdy hook wymaga potwierdzenia użytkownika, prompt uprawnień pokazuje teraz źródło hooka (settings, plugin lub skill), ułatwiając identyfikację, który komponent żąda dostępu.¹²⁴

Hooks z zakresem komponentu (v2.1.0+)

Hooks można definiować bezpośrednio w Skills, subagentach i poleceniach slash przy użyciu frontmatter. Te hooks mają zakres cyklu życia komponentu i działają tylko wtedy, gdy ten komponent jest aktywny.⁴¹

Skill z osadzonymi hookami:

---
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 uruchamia się tylko raz na sesję, co jest przydatne dla zadań czyszczenia lub finalizacji.

Strategia długo trwających sesji

W przypadku nocnych lub bezobsługowych sesji Claude Code proszę skonfigurować hooks, aby utrzymywać Claude na właściwym torze bez ręcznej interwencji. Kluczowy wniosek: warto używać hooków do lintingu i testowania jako poręczy, które zmuszają Claude do naprawy problemów przed kontynuowaniem.⁶⁴

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

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

Strategia dla nocnych sesji:

1. Kontrola przedstartowa: Proszę użyć hooka Setup, aby zweryfikować gotowość środowiska
2. Ciągła walidacja: Hooks PostToolUse uruchamiają testy po każdej zmianie
3. Brama ukończenia: Hooks Stop weryfikują wszystkie kryteria akceptacji, zanim Claude zadeklaruje „done”
4. Powiadomienia: Hooks Stop mogą powiadamiać użytkownika przez Slack/Pushover, gdy Claude skończy lub utknie

W połączeniu z --dangerously-skip-permissions w sandboxowanym kontenerze pozwala to na w pełni autonomiczne nocne uruchomienia. Claude będzie iterował, dopóki testy nie przejdą lub wyczerpią się jego opcje.

Czym jest MCP (Model Context Protocol)?

MCP rozszerza Claude Code o dostęp do zewnętrznych narzędzi, baz danych, API i usług za pośrednictwem standardowego protokołu. Ekosystem przeżył eksplozję: MCP ma obecnie 100 milionów miesięcznych pobrań oraz ponad 3000 serwerów zindeksowanych na MCP.so (styczeń 2026), co umacnia jego pozycję jako standardu branżowego dla łączenia AI z narzędziami i danymi.³⁵⁴ Zrozumienie MCP jest niezbędne do zintegrowania Claude z istniejącym łańcuchem narzędzi.

Dlaczego MCP ma znaczenie dla deweloperów: Bez MCP Claude Code może jedynie czytać pliki i wykonywać polecenia bash. Z MCP Claude może odpytywać produkcyjną bazę danych, tworzyć zgłoszenia w Jira, recenzować PR-y w GitHub, sprawdzać błędy w Sentry oraz wchodzić w interakcję z dowolnym API używanym przez zespół — wszystko to z poziomu zapytań w języku naturalnym. Protokół standaryzuje sposób, w jaki narzędzia AI łączą się z usługami zewnętrznymi, zapobiegając uzależnieniu od jednego dostawcy. Patrz Decision Frameworks, aby uzyskać wskazówki, kiedy stosować MCP, a kiedy inne mechanizmy rozszerzeń.

Obsługa zdalnego 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 raz się uwierzytelnić, a Claude Code automatycznie obsłuży odświeżanie tokenów.

# 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

SDK mcp_authenticate redirectUri (v2.1.121+): Funkcja mcp_authenticate w Agent SDK akceptuje parametr redirectUri służący do dokończenia OAuth na niestandardowych schematach URI — wymagane dla aplikacji desktopowych oraz przepływów konektorów claude.ai, które nie mogą wykorzystać domyślnego przekierowania loopback.¹⁶¹

Konektory MCP claude.ai (v2.1.46+)

Claude Code może teraz korzystać z konektorów MCP skonfigurowanych na koncie claude.ai. Wypełnia to lukę między wersją webową a CLI: serwery MCP skonfigurowane przez interfejs claude.ai są automatycznie dostępne w Claude Code bez konieczności ich ponownej konfiguracji lokalnie.¹⁰²

Wyłączenie: Należy ustawić ENABLE_CLAUDEAI_MCP_SERVERS=false w środowisku lub w bloku env pliku settings.json, aby zapobiec ładowaniu serwerów MCP z claude.ai.¹¹¹

Wyszukiwanie narzędzi MCP (v2.1.7+)

W miarę rozwoju możliwości serwerów MCP (niektóre udostępniają ponad 50 narzędzi), opisy narzędzi zaczęły zużywać nadmiernie dużo kontekstu. MCP Tool Search rozwiązuje ten problem poprzez dynamiczne ładowanie opisów narzędzi tylko wtedy, gdy są potrzebne — jest to forma leniwego ładowania (lazy loading) dla narzędzi AI.⁵⁴

Wpływ na wydajność: Wewnętrzne testy 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 narzutu tokenów: 85%

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

Konfiguracja:

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

Wartości: - true - Zawsze włącz wyszukiwanie narzędzi - false - Zawsze wyłącz (ładuj wszystkie opisy narzędzi z góry) - auto:N - Włącz, gdy narzędzia przekraczają N% kontekstu (0-100)

Wskazówka eksperta: Z włączonym Tool Search można podłączyć znacznie więcej serwerów MCP bez obaw o limity kontekstu. 95% redukcja kontekstu oznacza, że serwery, które wcześniej rywalizowały o kontekst, teraz współistnieją bezkonfliktowo.

Wymuszone ładowanie MCP (v2.1.121+)

Tool Search odracza ładowanie pełnych opisów do momentu, gdy narzędzie jest potrzebne (próg: mcpToolSearchAutoEnable, domyślnie auto:10). W przypadku zaufanych serwerów, których narzędzi spodziewa się Pan/Pani używać w każdej turze, można zrezygnować z tego mechanizmu dla konkretnego serwera za pomocą alwaysLoad: true — każde narzędzie z tego serwera jest ładowane do promptu na początku sesji, bez konieczności wykonywania zapytania ToolSearch:¹⁶¹

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "alwaysLoad": true
    }
  }
}

Automatyczne ponowne uruchamianie MCP (v2.1.121+): Serwer, który zgłasza błąd podczas uruchamiania, jest teraz ponawiany do 3 razy, zanim zostanie oznaczony jako rozłączony — przydatne dla serwerów stdio, które konkurują z wolno startującym procesem nadrzędnym, lub dla serwerów HTTP za zimno startującym backendem.¹⁶¹

MCP Elicitation (v2.1.76+)

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

Integracja z hookami: Dwa nowe zdarzenia hook — Elicitation (zanim okno dialogowe się pojawi) oraz ElicitationResult (po odpowiedzi użytkownika) — umożliwiają programowe przechwytywanie, walidację lub nadpisywanie odpowiedzi elicitation. Pozwala to na budowanie korporacyjnych przepływów pracy, w których prompty serwerów MCP są wstępnie wypełniane lub ograniczane przez zasady firmy.

Nadpisywanie rozmiaru wyniku MCP (v2.1.91+)

Wyniki narzędzi MCP są domyślnie obcinane. Serwery mogą to nadpisać dla każdego wyniku za pomocą adnotacji _meta["anthropic/maxResultSizeChars"], dopuszczając do 500 tys. znaków.¹⁴³ Przydaje się to przy zwracaniu dużych ładunków, takich jak schematy baz danych, odpowiedzi API lub zawartość plików, bez ich obcinania.

Interaktywny kreator konfiguracji MCP

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

Typy transportu

HTTP (zalecane dla zdalnych serwerów):

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łe, ale działa):

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

Stdio (lokalne serwery):

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

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

W systemie Windows stdio wymaga opakowania cmd:

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

Zarządzanie zakresami

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

Zakres można określić podczas instalacji:

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

Format pliku konfiguracyjnego

Plik .mcp.json definiuje serwery na poziomie projektu:

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

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

Polecenia zarządzania MCP

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

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

Uwierzytelnianie OAuth

Dla serwerów wymagających OAuth:

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

Korzystanie z zasobów i promptów MCP

Odwołania 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ścia

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

Można zwiększyć w razie potrzeby:

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 w środowisku korporacyjnym

Administratorzy systemu mogą egzekwować polityki MCP za pomocą pliku managed-mcp.json:

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

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

Lista odmów ma absolutny priorytet. Polecenia muszą się zgadzać dokładnie, włącznie z kolejnością argumentów.

MCP Apps (styczeń 2026)

Anthropic uruchomiło MCP Apps, rozszerzenie Model Context Protocol, które umożliwia interaktywne interfejsy narzędzi bezpośrednio wewnątrz interfejsu Claude.⁷⁸ MCP Apps pozwala użytkownikom przeglądać, edytować oraz wchodzić w interakcję z treścią z usług zewnętrznych bez opuszczania Claude, w tym Asana, Box, Canva, Figma, Hex, monday.com oraz Slack. Każdy serwer MCP może dostarczyć interaktywny UI renderowany wewnątrz Claude. Choć MCP Apps obecnie pojawiają się w interfejsie webowym claude.ai, leżące u ich podstaw rozszerzenia protokołu MCP mają znaczenie dla ekosystemu MCP w Claude Code, w miarę jak serwery przyjmują nowe interaktywne możliwości.

Platforma API: Code Execution Tool v2 (styczeń 2026)

Anthropic uruchomiło wersję v2 narzędzia Code Execution Tool w publicznej wersji beta, zastępując oryginalny sandbox obsługujący wyłącznie Python wykonywaniem poleceń Bash oraz 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ż publiczna beta): Claude może wywoływać narzędzia z poziomu wykonywania kodu, redukując opóźnienia i zużycie tokenów w przepływach wielonarzędziowych

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

Czym są subagenty?

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

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

Jak działają subagenty

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

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

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

Wbudowane typy subagentów

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

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

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

Uruchamianie subagentów

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

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

> Have a subagent analyze the database schema thoroughly

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

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

Tworzenie własnych subagentów

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

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

You are a senior security engineer reviewing code for vulnerabilities.

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

Focus on actionable security findings, not style issues.

Pola konfiguracyjne:

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

Subagenty definiowane z CLI (v2.1.32+)

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

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

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

Zarządzanie subagentami

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

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

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

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

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

Uruchamianie agentów w tle

W przypadku długotrwałych zadań:

> Run a thorough security review in the background

> /agents  # Check status of running agents

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

Zaawansowane wzorce

Łańcuchowe subagenty:

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