Claude Code działa jako system agentowy, a nie interfejs czatu z wiedzą programistyczną. CLI odczytuje bazę kodu, wykonuje polecenia, modyfikuje pliki, zarządza przepływami pracy git, łączy się z zewnętrznymi usługami poprzez MCP i deleguje złożone zadania do wyspecjalizowanych subagentów. Wszystko przepływa przez interfejs wiersza poleceń, który integruje się ze sposobem, w jaki programiści faktycznie pracują.

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

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

Spędziłem miesiące, testując Claude Code do granic możliwości w produkcyjnych bazach kodu, potokach CI/CD i wdrożeniach korporacyjnych. Ten przewodnik destyluje to doświadczenie w kompleksowe kompendium, które chciałbym mieć, gdy zaczynałem. Każda funkcja zawiera rzeczywistą składnię, prawdziwe przykłady konfiguracji oraz przypadki brzegowe, które sprawiają trudności nawet doświadczonym użytkownikom.

Jak działa Claude Code: Model mentalny

Zanim zagłębimy się w funkcje, warto zrozumieć, jak architektura Claude Code kształtuje wszystko, co można z nim zrobić. System działa w trzech warstwach:

┌─────────────────────────────────────────────────────────┐
│                    WARSTWY CLAUDE CODE                   │
├─────────────────────────────────────────────────────────┤
│  WARSTWA ROZSZERZEŃ                                      │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │   MCP   │  │  Hooks  │  │ Skills  │  │ Plugins │    │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘    │
│  Zewnętrzne narzędzia, deterministyczna automatyzacja,  │
│  wiedza domenowa, pakietowane rozszerzenia               │
├─────────────────────────────────────────────────────────┤
│  WARSTWA DELEGACJI                                       │
│  ┌─────────────────────────────────────────────────┐    │
│  │              Subagents (do 10 równolegle)        │    │
│  │   Explore | Plan | General-purpose | Custom      │    │
│  └─────────────────────────────────────────────────┘    │
│  Izolowane konteksty do skupionej pracy, zwracają       │
│  podsumowania                                            │
├─────────────────────────────────────────────────────────┤
│  WARSTWA GŁÓWNA                                          │
│  ┌─────────────────────────────────────────────────┐    │
│  │         Główny kontekst konwersacji              │    │
│  │   Narzędzia: Read, Edit, Bash, Glob, Grep, itd. │    │
│  └─────────────────────────────────────────────────┘    │
│  Główna interakcja; ograniczony kontekst; kosztuje      │
└─────────────────────────────────────────────────────────┘

Warstwa główna: Główna konwersacja. Każda wiadomość, odczyt pliku i wynik narzędzia zużywa kontekst ze współdzielonego okna 200K tokenów (1M w wersji premium). Gdy kontekst się zapełni, Claude traci orientację w wcześniejszych decyzjach i jakość spada. Ta warstwa kosztuje pieniądze za token.

Warstwa delegacji: Subagents uruchamiają się z czystymi kontekstami, wykonują skupioną pracę i zwracają podsumowania. Wyniki eksploracji nie obciążają głównej konwersacji — wracają tylko wnioski. Można używać subagents Haiku do eksploracji (tanie, szybkie) i Sonnet do implementacji.

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

Kluczowa obserwacja: Większość użytkowników pracuje wyłącznie w warstwie głównej, obserwując jak kontekst rośnie, a koszty rosną. Zaawansowani użytkownicy przenoszą eksplorację i wyspecjalizowaną pracę do warstwy delegacji, utrzymują warstwę rozszerzeń skonfigurowaną pod swój przepływ pracy i używają warstwy głównej tylko do orkiestracji i końcowych decyzji.

Spis treści

1. Jak zainstalować Claude Code?
2. Podstawowe tryby interakcji
3. System konfiguracji — szczegółowy opis
4. Który model wybrać?
5. Jak działa system uprawnień?
6. Jak działają Hooks?
7. Czym jest MCP (Model Context Protocol)?
8. Czym są Subagents?
9. Czym jest tryb Extended Thinking?
10. Style wyjścia
11. Slash Commands
12. Jak działają Skills?
13. System Plugins
14. Jak działa pamięć?
15. Obrazy i wejście multimodalne
16. Jak działa integracja z Git?
17. Jak używać Claude Code w IDE?
18. Zaawansowane wzorce użycia
19. Czym jest Claude Code Remote?
20. Czym są Background Agents?
21. Claude in Chrome
22. Claude Code in Slack
23. Ile kosztuje Claude Code?
24. Optymalizacja wydajności
25. Jak debugować problemy?
26. Wdrożenia korporacyjne
27. Skróty klawiszowe — dokumentacja
28. Najlepsze praktyki

Jak zainstalować Claude Code?

Wymagania systemowe

Claude Code działa na macOS 10.15+, Ubuntu 20.04+/Debian 10+ oraz Windows 10+ przez WSL lub Git Bash. System wymaga minimum 4 GB RAM i aktywnego połączenia internetowego. Kompatybilność powłoki działa najlepiej z Bash, Zsh lub Fish.

Dla Windows działają zarówno WSL 1, jak i WSL 2. Git Bash również działa, jeśli preferuje się natywny Windows. Alpine Linux i inne systemy oparte na musl wymagają dodatkowych pakietów:

apk add libgcc libstdc++ ripgrep
export USE_BUILTIN_RIPGREP=0

Metody instalacji

Instalacja natywna (zalecana)

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

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

# Homebrew alternative
brew install --cask claude-code

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

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

Instalacja konkretnej wersji:

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

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

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

Instalacja przez NPM (przestarzała)

Uwaga: Od wersji v2.1.15 instalacje przez npm wyświetlają powiadomienie o wycofaniu. Natywny plik binarny jest teraz zalecaną metodą instalacji. Można przeprowadzić migrację poleceniem claude install.

Dla starszych środowisk, gdzie npm jest nadal potrzebny:

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

Nigdy nie należy używać sudo przy instalacji npm — tworzy to problemy z uprawnieniami, które komplikują wszystko w dalszych krokach.

Migracja z istniejącej instalacji

Jeśli istnieje starsza instalacja oparta na npm, można przeprowadzić migrację do natywnego pliku binarnego:

claude install

Opcje uwierzytelniania

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

Claude Console (rozliczenie API)

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

Subskrypcja Claude Pro lub Max

Można użyć danych logowania do konta claude.ai. Subskrypcja obejmuje zarówno interfejs webowy, jak i użycie CLI w ramach jednego miesięcznego planu. Upraszcza to rozliczenia dla indywidualnych użytkowników, którzy chcą przewidywalnych kosztów.

Platformy korporacyjne

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

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

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

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

Dla wdrożeń korporacyjnych za proxy lub przez 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

To polecenie raportuje typ instalacji, wersję, konfigurację systemu i wszelkie wykryte problemy.

Aktualizacje

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

Wyłączenie automatycznych aktualizacji:

export DISABLE_AUTOUPDATER=1

Lub w settings.json:

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

Ręczna aktualizacja:

claude update

Dezinstalacja

Instalacja natywna (macOS/Linux/WSL):

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

Instalacja natywna (Windows PowerShell):

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

Czyszczenie konfiguracji (usuwa wszystkie ustawienia):

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

Podstawowe tryby interakcji

Interaktywny REPL

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

cd your-project
claude

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

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

claude "explain the authentication flow in this project"

Wskazówka ekspercka: REPL zachowuje stan między zdarzeniami kompaktowania. Gdy kontekst staje się zbyt duży, Claude automatycznie podsumowuje starszą część rozmowy, zachowując kluczowe decyzje i fragmenty kodu. Można to wywołać ręcznie za pomocą /compact lub dodać własne instrukcje określające, co 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ć ustrukturyzowane wyjście odpowiednie do parsowania w skryptach:

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

Wyjście JSON zawiera wszystko, czego potrzeba do automatyzacji:

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

Aby przetwarzać strumieniowe wyjście w czasie rzeczywistym:

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

Zarządzanie sesjami

Sesje zachowują historię rozmów w celu ich kontynuacji. Jest to niezbędne przy złożonej pracy wielosesyjnej:

# Continue most recent session
claude -c

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

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

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

Tworzenie odtwarzalnych sesji z jawnymi identyfikatorami:

claude --session-id "feature-auth-$(date +%s)"

Wskazówka ekspercka: Warto używać identyfikatorów sesji, które kodują kontekst: feature-${branch}-${timestamp} lub bug-JIRA-123. Gdy wraca się do nich po kilku dniach, sam identyfikator mówi, czego dotyczyła sesja. Dostępne sesje można przeglądać w REPL za pomocą /resume.

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

Nazwane sesje (grudzień 2025): Łatwiejsze nazywanie i zarządzanie sesjami:

# Name current session
> /rename my-feature-work

# Resume by name or number
> /resume 1                    # Resume first session
> /resume my-feature-work      # Resume by name
claude --resume 3              # Resume from terminal

# Fork with custom session ID
claude --session-id "new-exploration" --resume "base-session" --fork-session

System konfiguracji — szczegółowe omówienie

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

Hierarchia konfiguracji

Wskazówka ekspercka: Plik .claude/settings.local.json służy do osobistych preferencji we współdzielonych projektach — powinien być uwzględniony w .gitignore. Plik .claude/settings.json jest przeznaczony do konfiguracji zespołowej, która trafia do systemu kontroli wersji.

Kompletna dokumentacja settings.json

Kompleksowa konfiguracja prezentująca wszystkie główne opcje:

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

Zmienne środowiskowe — dokumentacja

Uwierzytelnianie i API:

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

Konfiguracja modelu:

ANTHROPIC_MODEL=claude-opus-4-5                 # Override default model
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-5-20251101
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-5-20250929-v1:0
ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5-20251001
CLAUDE_CODE_SUBAGENT_MODEL=sonnet               # Model for subagents
MAX_THINKING_TOKENS=10000                       # Enable extended thinking
CLAUDE_CODE_MAX_OUTPUT_TOKENS=4000              # Limit output length

Konfiguracja dostawców chmurowych:

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

Sterowanie zachowaniem:

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

Konfiguracja narzędzi:

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

Sieć i proxy:

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

Interfejs użytkownika i terminal:

CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1            # Don't update terminal title
CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1             # Skip IDE extension install
CLAUDE_CODE_SHELL=/bin/zsh                      # Override shell detection
USE_BUILTIN_RIPGREP=1                           # Use included ripgrep (default)
CLAUDE_CONFIG_DIR=~/.myconfig                   # Custom config directory
IS_DEMO=1                                       # Hide sensitive UI elements[^37]
CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1          # Disable background tasks and Ctrl+B[^46]
CLAUDE_CODE_TMPDIR=/path/to/tmp                 # Override temp directory[^50]

Debugowanie:

ANTHROPIC_LOG=debug                             # Enable API request logging

Który model wybrać?

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

Dostępne modele

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 za sesję. Z Opus ta sama sesja kosztuje $0.50-$2.25—5x więcej. Opus należy rezerwować dla naprawdę trudnych problemów.¹

Kiedy używać każdego modelu

Haiku: Używaj do subagentów wykonujących eksplorację, prostych wyszukiwań plików, szybkich pytań. Jest 10-20x tańszy niż Opus i odpowiada szybciej. Idealny do zadań w tle, gdzie nie potrzeba głębokiego rozumowania.

Sonnet: Koń pociągowy codziennego programowania. Dobrze radzi sobie z większością zadań kodowania: implementacja funkcji, naprawianie błędów, pisanie testów, przegląd kodu. Używaj jako domyślny model.

Opus: Rezerwuj dla naprawdę złożonego rozumowania: decyzje architektoniczne, trudne debugowanie, zrozumienie złożonych systemów, analiza bezpieczeństwa. Różnica w jakości jest realna dla trudnych problemów, ale koszt również. Opus 4.5 osiąga 80.9% na SWE-bench Verified, jednocześnie zmniejszając zużycie tokenów o połowę w porównaniu z poprzednikami.⁴⁵ Uwaga: Użytkownicy subskrypcji Pro mają teraz dostęp do Opus 4.5 w ramach swojej subskrypcji.²⁰

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

Przełączanie modeli

Podczas sesji:

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

Przy uruchomieniu:

claude --model opus

Przez zmienne środowiskowe:

export ANTHROPIC_MODEL=opus

W settings.json:

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

Specjalnie dla subagentów:

export CLAUDE_CODE_SUBAGENT_MODEL=haiku

Rozszerzony kontekst

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

claude --model sonnet[1m]

Lub w trakcie sesji:

> /model anthropic.claude-sonnet-4-5-20250929-v1:0[1m]

Rozszerzony kontekst kosztuje więcej za token. Należy go używać, gdy rzeczywiście jest potrzebny, nie jako domyślne ustawienie.

Sprawdzanie bieżącego modelu

> /status

Pokazuje to bieżący model, informacje o koncie, zastosowane ustawienia i inne dane stanu sesji.

Ramy decyzyjne

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

Którego modelu powinienem 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
                  │         Koszt: ~$2.00/zadanie
                  │         Jakość: Najwyższa
                  │
                  └── NIE → Użyj Sonnet (domyślnie)
                           Koszt: ~$0.75/zadanie
                           Równowaga: Najlepsza ogólnie

Praktyczna zasada: Zacznij od Sonnet. Przejdź na Haiku dla subagentów. Eskaluj do Opus tylko wtedy, gdy odpowiedź Sonnet wydaje się powierzchowna.

Polecenie, skill czy subagent?

Czy chcesz mieć jawną kontrolę nad momentem uruchomienia?
│
├── TAK → Użyj slash command
│         Przykład: /deploy, /test, /security-review
│         Ty wywołujesz. Ty kontrolujesz moment.
│
└── NIE → Czy wiedza specjalistyczna powinna być stosowana automatycznie na podstawie kontekstu?
         │
         ├── TAK → Użyj skill
         │         Przykład: Wzorce bezpieczeństwa, reguły domenowe, standardy kodu
         │         Claude rozpoznaje kontekst i stosuje wiedzę specjalistyczną.
         │
         └── NIE → Czy praca wymaga izolowanego kontekstu?
                  │
                  ├── TAK → Użyj subagent
                  │         Przykład: Głęboka eksploracja, równoległa analiza
                  │         Zapobiega rozrostowi kontekstu w głównej konwersacji.
                  │
                  └── NIE → Po prostu zapytaj bezpośrednio
                           Nie wszystko wymaga abstrakcji.

Hook czy prompt?

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

Kiedy używać rozszerzonego myślenia?

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

Przełączaj klawiszem Tab podczas sesji. Wyższe budżety thinking kosztują więcej—zacznij od minimum i zwiększaj tylko wtedy, gdy odpowiedzi wydają się pospieszne.

Jak działa system uprawnień?

System uprawnień Claude Code zapewnia szczegółową kontrolę nad tym, jakie operacje mogą być wykonywane. Zrozumienie go jest niezbędne zarówno dla bezpieczeństwa, jak i efektywności pracy.

Poziomy uprawnień

Narzędzia tylko do odczytu (automatycznie zatwierdzane): - Read - Odczyt zawartości plików - Glob - Wyszukiwanie plików według wzorca - Grep - Przeszukiwanie zawartości plików - WebSearch - Wyszukiwanie w sieci - LSP - Inteligencja kodu (przejście do definicji, znajdowanie referencji, dokumentacja przy najechaniu)²⁵

Możliwości narzędzia LSP (v2.0.74+): Narzędzie LSP zapewnia inteligencję kodu podobną do IDE: - Przejście do definicji: Skok do miejsca, gdzie symbol jest zdefiniowany - Znajdowanie referencji: Lista wszystkich użyć symbolu w całej bazie kodu - Dokumentacja przy najechaniu: Informacje o typie i dokumentacja dla dowolnego symbolu - Działa z TypeScript, Python, Go, Rust i innymi językami ze wsparciem LSP - Wymaga dostępności serwera językowego (zwykle instalowanego wraz z zestawem narzędzi)

Narzędzia modyfikujące (wymagają zatwierdzenia): - Edit - Modyfikacja istniejących plików - Write - Tworzenie nowych plików - Bash - Wykonywanie poleceń powłoki - WebFetch - Pobieranie zawartości URL - NotebookEdit - Modyfikacja notatników Jupyter

Przy pierwszym uruchomieniu narzędzia modyfikującego Claude Code prosi o zatwierdzenie. Zatwierdzenia są zapamiętywane na czas sesji, chyba że skonfigurowano inaczej.

Tryby uprawnień

Tryb YOLO (v2.0.68+): Dla w pełni autonomicznej pracy można użyć flagi --dangerously-skip-permissions. Odpowiada ona „tak” na wszystko—edycje plików, polecenia bash, wszystkie wywołania narzędzi. Słowo „dangerously” (niebezpiecznie) jest celowe. Należy używać w środowiskach izolowanych lub gdy w pełni ufamy bazie kodu.⁶¹

claude --dangerously-skip-permissions

Ustawianie trybu przez CLI:

claude --permission-mode acceptEdits

Przełączanie podczas sesji:

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

W settings.json:

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

Składnia reguł uprawnień

Szczegółowe reguły kontrolują konkretne operacje. Reguły są sprawdzane po kolei: wygrywa pierwsze dopasowanie.

Wzorce poleceń Bash:

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

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

Ważne ograniczenie: Wzorce Bash dopasowują tylko prefiksy, nie wyrażenia regularne. Wzorzec taki jak Bash(curl http:*) nie dopasuje curl -X GET http://..., ponieważ opcje występują przed URL. Dla niezawodnego blokowania należy całkowicie zabronić polecenia: Bash(curl:*).

Wzorce operacji na plikach:

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

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

Wzorce narzędzi MCP:

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

Można użyć składni z symbolem wieloznacznym mcp__server__*, aby zezwolić lub zabronić wszystkich narzędzi z konkretnego serwera MCP.³⁹ Jest to przydatne do szybkiego włączania wszystkich narzędzi z zaufanych serwerów lub blokowania całych serwerów z niezaufanych źródeł.

Wzorce WebFetch:

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

Dodatkowe katalogi

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

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

Jest to niezbędne dla monorepo lub gdy Claude musi odwoływać się do kodu w katalogach sąsiednich.

Tryb piaskownicy

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

> /sandbox

Lub konfiguracja w ustawieniach:

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

W trybie piaskownicy: - Dostęp do systemu plików ograniczony do katalogu projektu - Kontrolowany dostęp do sieci - Niektóre polecenia wyłączone z ograniczeń piaskownicy - Polecenia Bash automatycznie zatwierdzane, jeśli autoAllowBashIfSandboxed jest włączone

Wskazówka eksperta: Tryb piaskownicy jest doskonały do uruchamiania Claude na niezaufanych bazach kodu. Należy go włączyć podczas eksploracji nieznanych projektów lub gdy potrzebna jest dodatkowa warstwa ochrony. Wewnętrzne testy Anthropic wykazały, że piaskownica zmniejsza liczbę pytań o uprawnienia o 84%.⁴⁵

Jak działają hooki?

Hooki wykonują deterministyczne polecenia powłoki w określonych momentach przepływu pracy Claude Code. W przeciwieństwie do instruowania Claude’a, aby wykonał określone akcje, hooki gwarantują wykonanie niezależnie od zachowania modelu. Są niezbędne do egzekwowania standardów zespołu i automatyzacji powtarzalnych zadań.

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

Dostępne zdarzenia

Konfiguracja hooków

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

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

Matchery

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

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

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

Hooki otrzymują JSON na stdin:

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

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

Dla zaawansowanej kontroli hooki mogą zwracać JSON:

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

Hooki PreToolUse z uprawnieniem ask (v2.1.0+): Hooki PreToolUse mogą teraz zwracać updatedInput przy użyciu decyzji uprawnienia „ask”, umożliwiając hookom działanie jako middleware przy jednoczesnym żądaniu zgody użytkownika.³⁹

{
  "decision": "ask",
  "message": "Modified command requires approval",
  "updatedInput": {
    "command": "npm test -- --coverage --ci"
  }
}

Hooki PreToolUse z additionalContext (v2.1.9+): Hooki mogą wstrzykiwać kontekst do modelu poprzez zwracanie additionalContext. Jest to przydatne do dostarczania dynamicznych informacji (dokumentacja API, schematy bazy danych, stan środowiska), które model powinien uwzględnić.⁵¹

{
  "decision": "allow",
  "additionalContext": "Note: This database has a 5-second query timeout. Complex joins may need optimization."
}

Ciąg additionalContext jest dołączany do kontekstu modelu dla danej tury, udostępniając go do rozumowania bez trwałej modyfikacji konwersacji.

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 1
fi
exit 0

Uruchamianie testów po zmianach w kodzie:

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

Niestandardowy system powiadomień:

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

Wstrzykiwanie dynamicznego kontekstu do promptów:

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

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

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

Debugowanie hooków

Włączenie trybu debug pozwala diagnozować problemy z hookami:

claude --debug

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

Hooki z zakresem komponentu (v2.1.0+)

Hooki mogą być definiowane bezpośrednio w Skills, subagentach i slash commands przy użyciu frontmatter. Te hooki mają zakres ograniczony do cyklu życia komponentu i uruchamiają się tylko gdy dany 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 dla skills i slash commands) zapewnia, że hook uruchomi się tylko raz na sesję — przydatne dla zadań czyszczenia lub finalizacji.

Strategia dla długotrwałych sesji

Dla nocnych lub nienadzorowanych sesji Claude Code należy skonfigurować hooki, które utrzymują Claude’a na właściwym torze bez ręcznej interwencji. Kluczowa obserwacja: hooki lintingu i testowania działają jako bariery ochronne, które wymuszają naprawienie problemów przed kontynuowaniem.⁶⁴

Wzorzec „Nie kończ dopóki testy nie przechodzą”:

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

Strategia dla sesji nocnych:

1. Sprawdzenie przed startem: Użycie hooka Setup do weryfikacji gotowości środowiska
2. Ciągła walidacja: Hooki PostToolUse uruchamiają testy po każdej zmianie
3. Bramka zakończenia: Hooki Stop weryfikują wszystkie kryteria akceptacji przed ogłoszeniem przez Claude’a „zakończone”
4. Powiadomienia: Hooki Stop mogą powiadamiać przez Slack/Pushover gdy Claude kończy lub utyka

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

Czym jest MCP (Model Context Protocol)?

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

Dlaczego MCP jest ważny dla programistów: Bez MCP Claude Code może jedynie odczytywać pliki i uruchamiać polecenia bash. Z MCP Claude może odpytywać produkcyjną bazę danych, tworzyć zgłoszenia w Jira, przeglądać pull requesty na GitHub, sprawdzać błędy w Sentry i komunikować się z dowolnym API używanym przez zespół — wszystko za pomocą zapytań w języku naturalnym. Protokół standaryzuje sposób, w jaki narzędzia AI łączą się z zewnętrznymi usługami, zapobiegając uzależnieniu od jednego dostawcy.

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 jednorazowe uwierzytelnienie, a Claude Code automatycznie obsługuje 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

MCP Tool Search (v2.1.7+)

W miarę jak serwery MCP zyskiwały na funkcjonalności (niektóre udostępniają ponad 50 narzędzi), opisy narzędzi zaczęły zużywać nadmierną ilość kontekstu. MCP Tool Search rozwiązuje ten problem, dynamicznie ładując opisy narzędzi tylko wtedy, gdy są potrzebne — to forma leniwego ładowania dla narzędzi AI.⁵⁴

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

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

Konfiguracja:

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

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

Wskazówka dla zaawansowanych: Przy włączonym Tool Search można podłączyć znacznie więcej serwerów MCP bez obaw o limity kontekstu. 95-procentowa redukcja kontekstu oznacza, że serwery, które wcześniej konkurowały o kontekst, teraz współistnieją bez problemów.

Interaktywny kreator konfiguracji MCP

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

Typy transportu

HTTP (zalecany dla serwerów zdalnych):

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

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

SSE (przestarzały, ale funkcjonalny):

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

Stdio (serwery lokalne):

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

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

W systemie Windows wymagany jest wrapper cmd dla stdio:

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

Zarządzanie zakresami

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

Określanie zakresu podczas instalacji:

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

Format pliku konfiguracyjnego

Plik .mcp.json definiuje serwery na poziomie projektu:

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

Zmienne środowiskowe są rozwijane za pomocą składni ${VAR} z opcjonalnymi wartościami domyślnymi: ${VAR:-default}.

Polecenia zarządzania MCP

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

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

Uwierzytelnianie OAuth

Dla serwerów wymagających OAuth:

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

Korzystanie z zasobów i promptów MCP

Odwoływanie się do zasobów:

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

Prompty MCP jako polecenia slash:

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

Limity wyjściowe

Dane wyjściowe MCP są ograniczone, aby zapobiec przepełnieniu kontekstu: - Próg ostrzeżenia: 10 000 tokenów - Domyślne maksimum: 25 000 tokenów

Zwiększenie 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 dla przedsiębiorstw

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

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

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

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

MCP Apps (styczeń 2026)

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

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

Anthropic uruchomił v2 narzędzia Code Execution Tool w publicznej becie, zastępując oryginalny sandbox ograniczony do Pythona wykonywaniem poleceń Bash i bezpośrednią manipulacją plikami.⁷⁹ Kluczowe zmiany: - Wykonywanie poleceń Bash (nie tylko Python) w izolowanych kontenerach - Pisanie i uruchamianie kodu w dowolnym języku - Programistyczne wywoływanie narzędzi (również w publicznej becie): Claude może wywoływać narzędzia z poziomu wykonywania kodu, redukując opóźnienia i zużycie tokenów w przepływach pracy z wieloma narzędziami

Dotyczy to przede wszystkim użytkowników API, ale wskazuje kierunek rozwoju możliwości wykonywania kodu w chmurze przez 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 jednocześnie jedną z najmniej zrozumianych. Opanowanie subagentów znacząco rozszerza możliwości pracy.

Dlaczego istnieją subagenty: Główna konwersacja Claude Code ma jedno okno kontekstu. Wszystko, o czym rozmawiamy, każdy plik, który Claude odczytuje, każdy wynik narzędzia — wszystko to zużywa kontekst. W długich sesjach kontekst się zapełnia, Claude traci orientację we wcześniejszych decyzjach, 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 równoczesną pracę, która byłaby niemożliwa sekwencyjnie.²

Jak działają subagenty

Gdy Claude napotka zadanie, które wymaga skoncentrowanej uwagi — głębokiej eksploracji, wieloetapowej analizy, specjalistycznej pracy — może uruchomić subagenta. Subagent:

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

Ta 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: Ściśle tylko 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, zrozumienie struktury

General-purpose: - Model: Sonnet - Tryb: Pełny odczyt/zapis - Narzędzia: Wszystkie dostępne narzędzia - Zastosowanie: Złożone zadania badawcze + modyfikacyjne

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

Wywoływanie subagentów

Claude automatycznie deleguje do subagentów w zależności od typu zadania. Można również jawnie o nie 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: Przy złożonych zadaniach warto jawnie zażądać delegacji do subagenta. „Use an explore agent to find…” zapobiega obciążaniu kontekstu 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:

Zarządzanie subagentami

> /agents                    # Interaktywne zarządzanie
> /agents create             # Tworzenie nowego subagenta
> /agents edit               # Modyfikacja istniejącego
> /agents delete             # Usunięcie subagenta
> /agents list               # Wyświetlenie wszystkich

Uruchamianie agentów w tle

Dla długotrwałych zadań:

> Run a thorough security review in the background

> /agents  # Check status of running agents

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

Zaawansowane wzorce

Łańcuchowe subagenty:

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

Równoległa eksploracja:

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

Wznawianie agentów: Agenty można wznawiać za pomocą ich identyfikatora, aby kontynuować poprzednią pracę:

> Resume agent abc123 and continue the analysis

Asynchroniczne subagenty (grudzień 2025)

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

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

Asynchroniczne agenty zwracają wyniki poprzez ujednolicony TaskOutputTool, umożliwiając wydajne przepływy pracy w stylu potoku.

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

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

Agent Skills (grudzień 2025)

Agent Skills to zorganizowane foldery instrukcji, skryptów i zasobów, które agenty odkrywają i ładują dynamicznie.³¹ Zapewniają kompozycyjną, przenośną wiedzę ekspercką z danej dziedziny:

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

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

Czym jest tryb rozszerzonego myślenia?

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

Stan obecny (styczeń 2026)

Rozszerzone myślenie jest teraz domyślnie włączone z budżetem 31 999 tokenów — maksymalnym budżetem, który wcześniej był aktywowany przez „ultrathink”.⁷⁰ Ta zmiana została wprowadzona, ponieważ rozszerzone myślenie znacząco poprawia wydajność przy złożonych zadaniach planistycznych i rozumowania.

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

Obsługiwane modele

• Claude Opus 4.5
• Claude Sonnet 4.5
• Claude Haiku 4.5

Kontrolowanie rozszerzonego myślenia

Szybkie przełączanie podczas sesji:

Press Alt+T to toggle thinking on/off

Uwaga: Przełącznik myślenia został zmieniony z Tab na Alt+T, aby uniknąć przypadkowych aktywacji.³⁹

Poprzez /config: Przejdź do /config → Extended Thinking, aby włączyć/wyłączyć lub dostosować budżet.

Zmienna środowiskowa (stałe ustawienie):

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

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

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

export MAX_THINKING_TOKENS=8000  # Reduce from default 31,999

Budżety tokenów myślenia

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

Jak to działa

Gdy myślenie jest włączone, odpowiedź Claude zawiera wewnętrzne rozumowanie, które nie jest pokazywane w wyniku, ale wpływa na odpowiedź. Myślenie jest szyfrowane i zwracane w polu signature w celu weryfikacji.

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

Kiedy rozważyć wyłączenie/zmniejszenie

Rozszerzone myślenie jest teraz domyślne, ale warto rozważyć zmniejszenie budżetu lub wyłączenie dla: - Prostych edycji plików - Rutynowego refaktoringu - Szybkich pytań - Formatowania kodu - Operacji o dużej częstotliwości, gdzie koszty się kumulują

Zachowanie pamięci podręcznej

Pamięć podręczna promptu systemowego jest zachowywana przy zmianach parametrów myślenia. Pamięć podręczna wiadomości jest unieważniana, gdy budżet myślenia lub status włączenia zmienia się między turami.

Style wyjścia

Style wyjścia dostosowują sposób, w jaki Claude prezentuje informacje — przydatne do nauki, dokumentacji lub specyficznych preferencji zespołu.¹⁹

Wbudowane style

Ustawianie stylu wyjścia

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

Lub poprzez ustawienia:

{
  "outputStyle": "Explanatory"
}

Własne style wyjścia

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

# my-style

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

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

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

Polecenia Slash

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

Wbudowane polecenia — dokumentacja

Tworzenie niestandardowych poleceń

Tworzenie poleceń wielokrotnego użytku w .claude/commands/ (projekt) lub ~/.claude/commands/ (osobiste):

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

Review this code for security vulnerabilities:

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

Focus on actionable findings with specific line references.

Zapisz jako .claude/commands/security-review.md, wywołaj za pomocą /security-review.

Opcje frontmatter poleceń

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

Interpolacja argumentów

Wszystkie argumenty jako pojedynczy ciąg:

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

Fix GitHub issue #$ARGUMENTS following our coding standards.

Użycie: /fix-issue 123

Argumenty numerowane:

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

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

Użycie: /create-component Button functional

Wykonywanie Bash w linii

Wykonywanie poleceń bash w promptach poleceń:

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

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

Summarize the current state of this repository.

Referencje do plików

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

---
description: Compare implementations
---

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

Which implementation is more maintainable?

Przestrzenie nazw poleceń

Organizacja poleceń w podkatalogach:

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

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

Jak działają Skills?

Skills reprezentują fundamentalnie odmienne podejście do rozszerzania Claude Code. W przeciwieństwie do poleceń slash, które wywołujesz jawnie, skills są wywoływane przez model — Claude automatycznie je odkrywa i używa w zależności od kontekstu. Osadzasz wiedzę ekspercką w skill, a Claude korzysta z tej wiedzy, gdy sytuacja tego wymaga, bez konieczności pamiętania o pytaniu.

Dlaczego skills zmieniają wszystko: Rozważ wiedzę domenową — zasady przetwarzania płatności, wymagania zgodności, wzorce architektoniczne, które Twój zespół dopracowywał przez lata. Bez skills albo za każdym razem wyjaśniasz ten kontekst, albo masz nadzieję, że Claude wywnioskuje go z komentarzy w kodzie. Z skills kodujesz to raz. Claude czyta definicję skill i automatycznie stosuje tę wiedzę, gdy jest to istotne. Twoi młodsi programiści otrzymują wskazówki na poziomie seniora bez pytania. Twoje wzorce bezpieczeństwa są egzekwowane bez konieczności pamiętania o ich wywołaniu.

To rozróżnienie ma znaczenie. Polecenie slash to skrót, o którym pamiętasz, żeby go użyć. Skill to wiedza, którą Claude ma zawsze dostępną. Gdy tworzysz skill przeglądu bezpieczeństwa ze specyficznymi wzorcami podatności i wymaganiami zgodności Twojego zespołu, Claude stosuje tę wiedzę za każdym razem, gdy napotka odpowiedni kod — podczas przeglądów PR, refaktoryzacji lub dowolnego zadania, gdzie bezpieczeństwo ma znaczenie. Nie wywołujesz /security-review; Claude rozpoznaje kontekst i automatycznie stosuje skill.

Skills vs polecenia vs subagenci

Zrozumienie, kiedy używać każdego mechanizmu rozszerzeń, zapobiega duplikacji i maksymalizuje efektywność:

Używaj poleceń slash, gdy chcesz jawnej kontroli: /deploy, /test, /review PR 456. Ty decydujesz, kiedy je uruchomić.

Używaj skills, gdy wiedza ekspercka powinna być automatycznie dostępna: wzorce bezpieczeństwa, egzekwowanie stylu kodu, wiedza specyficzna dla domeny. Claude decyduje, kiedy je zastosować.

Używaj subagentów, gdy zadania wymagają izolacji: eksploracja w tle, równoległa analiza, wyspecjalizowane rozumowanie, które nie powinno zanieczyszczać głównej konwersacji.

Struktura i lokalizacja Skills

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

Skills osobiste (dostępne we wszystkich Twoich projektach):

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

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

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

Skills projektowe commituje się do kontroli wersji. Gdy członkowie zespołu pobierają zmiany, automatycznie otrzymują Twoje skills — bez instalacji, bez konfiguracji. W ten sposób standaryzujesz wiedzę ekspercką w całym zespole.

Format SKILL.md

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

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

# Code Review Expertise

## Security Analysis

When reviewing code, check for:

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

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

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

## Performance Patterns

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

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

## Format wyjścia przeglądu

Dla każdego znaleziska:
- **Plik**: path/to/file.ts:123
- **Ważność**: Krytyczna | Wysoka | Średnia | Niska
- **Kategoria**: Bezpieczeństwo | Wydajność | Utrzymywalność
- **Problem**: Jasny opis problemu
- **Zalecenie**: Konkretna poprawka z przykładem kodu
- **Uzasadnienie**: Dlaczego to jest istotne

Zobacz [SECURITY_PATTERNS.md](SECURITY_PATTERNS.md) dla szczegółowych wzorców podatności.
Zobacz [PERFORMANCE_CHECKLIST.md](PERFORMANCE_CHECKLIST.md) dla wytycznych optymalizacji.

Dokumentacja frontmatter

Podstawienia ciągów znaków (v2.1.9+): Skills mogą uzyskiwać dostęp do kontekstu sesji używając podstawienia ${CLAUDE_SESSION_ID}. Przydatne do logowania, śledzenia lub generowania wyników specyficznych dla sesji.⁵¹

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

Słaby opis:

description: Helps with code

Skuteczny opis:

description: Review code for security vulnerabilities, performance issues, and best practice violations. Use when examining code changes, reviewing PRs, analyzing code quality, or when asked to review, audit, or check code.

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

Ograniczenia narzędzi

Pole allowed-tools ogranicza, co Claude może robić, gdy skill jest aktywny. Jest to niezbędne dla skills, które powinny być tylko do odczytu lub ograniczone w zakresie:

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

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

Typowe wzorce ograniczeń:

Pliki pomocnicze

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

Wzorzec struktury:

my-skill/
├── SKILL.md           # Wymagane: przegląd + szybka referencja
├── DETAILED_GUIDE.md  # Szczegółowa dokumentacja
├── EXAMPLES.md        # Konkretne przykłady
├── PATTERNS.md        # Wzorce referencyjne
├── templates/         # Szablony wielokrotnego użytku
│   └── component.tsx
└── scripts/           # Narzędzia pomocnicze
    └── validate.py

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

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

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

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

**Wskazówka eksperta:** Umieść istotne informacje bezpośrednio w SKILL.md. Zarezerwuj pliki pomocnicze dla pogłębionych materiałów referencyjnych. Claude czyta SKILL.md natychmiast, ale uzyskuje dostęp do plików pomocniczych tylko gdy jest to potrzebne. Jeśli krytyczne informacje są ukryte w pliku pomocniczym, Claude może ich nie znaleźć.

### Kompletny przykład: Skill eksperta domenowego

Oto skill o jakości produkcyjnej dla aplikacji fintech:

**Struktura katalogów:**

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

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

# Payments Domain Expertise

## Core Concepts

### Transaction States

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

### Money Handling Rules
- ALL monetary values stored as integers (cents, not dollars)
- Currency always explicitly tracked (never assume USD)
- Rounding: HALF_EVEN for calculations, HALF_UP for display
- Never use floating point for money

### Idempotency Requirements
Every payment operation MUST be idempotent:
```typescript
// Required pattern
async function processPayment(idempotencyKey: string, amount: number) {
  const existing = await findByIdempotencyKey(idempotencyKey);
  if (existing) return existing; // Return cached result

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

Quick Reference

Fee Calculations

• Interchange: 1.5% + $0.10 (debit), 2.1% + $0.10 (credit)
• Platform fee: 2.9% + $0.30 (standard), 2.2% + $0.30 (enterprise)
• International: +1% cross-border fee
• Currency conversion: mid-market rate + 1%

Compliance Thresholds

• $3,000: Enhanced due diligence trigger
• $10,000: CTR filing required
• $25,000: Additional verification required

Refund Windows

• Full refund: 120 days from capture
• Partial refund: 180 days from capture
• Chargeback window: 120 days (Visa), 180 days (Mastercard)

Key Files

• src/payments/processor.ts - Core payment logic
• src/payments/refunds.ts - Refund handling
• src/compliance/aml.ts - AML checks
• src/models/transaction.ts - Transaction model

See BUSINESS_RULES.md for detailed business logic. See COMPLIANCE.md for regulatory requirements. See DATA_MODELS.md for schema documentation.

Z tym skillem Claude automatycznie stosuje wiedzę domenową o płatnościach, gdy pracujesz nad kodem transakcji, pytasz o logikę zwrotów lub debugujesz przepływy płatności. Nie wywołujesz niczego — wiedza jest po prostu dostępna.

### Tworzenie skutecznych skills

**Zacznij od opisu.** Najpierw napisz opis, następnie zbuduj zawartość skilla, aby do niego pasowała. Opis określa, kiedy Claude używa skilla, więc zrób to dobrze:

1. Określ, co skill zapewnia
2. Wymień konkretne warunki wyzwalania
3. Uwzględnij odpowiednie słowa kluczowe i frazy

**Utrzymuj skills skupione.** Jeden skill powinien obejmować jedną domenę lub możliwość:

| Dobre (skupione) | Złe (zbyt szerokie) |
|------------------|---------------------|
| `security-auditor` | `code-helper` |
| `react-patterns` | `frontend-stuff` |
| `postgres-optimization` | `database-expert` |
| `api-documentation` | `docs-generator` |

Jeśli skill próbuje obejmować zbyt wiele, jego opis staje się niejasny i Claude nie będzie niezawodnie rozpoznawał, kiedy go użyć.

**Używaj stopniowego ujawniania.** Umieść najważniejsze informacje bezpośrednio w SKILL.md. Odwołuj się do plików pomocniczych dla pogłębienia:

```markdown

## Quick Reference
[Essential patterns here - Claude sees this immediately]

## Deep Dive
For comprehensive coverage, see [DETAILED_GUIDE.md](DETAILED_GUIDE.md).

Uwzględnij konkretne przykłady. Abstrakcyjne opisy są mniej użyteczne niż konkretne wzorce:

## Input Validation

### Pattern
```typescript
// Good: Explicit validation with typed errors
const validated = PaymentSchema.safeParse(input);
if (!validated.success) {
  throw new ValidationError(validated.error.issues);
}

// Bad: Implicit coercion
const amount = Number(input.amount); // Silent NaN on invalid input

**Testuj z realistycznymi zapytaniami.** Po utworzeniu skilla przetestuj, czy Claude go aktywuje:

Review this payment processing code for issues

Should activate payments-domain skill

How should I handle refunds?

Should activate payments-domain skill

What’s the weather like?

Should NOT activate payments-domain skill

Jeśli Claude nie aktywuje skilla, gdy tego oczekujesz, zmień opis, aby zawierał frazy wyzwalające, których używasz.

### Strategie udostępniania zespołowego

**Udostępnianie oparte na Git (zalecane dla skills projektowych):**
```bash
# Add skill to project
mkdir -p .claude/skills/team-standard
# Create SKILL.md and supporting files

# Commit
git add .claude/skills/
git commit -m "Add team coding standards skill"
git push

# Teammates get it automatically
git pull
claude  # Skill now available

Udostępnianie między projektami przez dowiązania symboliczne:

# Create canonical skill location
mkdir -p ~/shared-skills/security-reviewer
# Create SKILL.md

# Symlink into projects
ln -s ~/shared-skills/security-reviewer ~/.claude/skills/security-reviewer
# Now available in all your projects

Dystrybucja przez plugins: Dla szerszej dystrybucji, pakuj skills do plugins:

my-plugin/
├── .claude-plugin/
│   └── plugin.json
└── skills/
    └── my-skill/
        └── SKILL.md

Skills dołączone do plugins stają się dostępne, gdy użytkownicy zainstalują plugin.

Debugowanie skills

Skill się nie aktywuje:

1. Sprawdź, czy opis pasuje do Twojego zapytania: yaml # If you're saying "check this code" but description says "review" description: Review OR check code for issues...

2. Zweryfikuj lokalizację pliku: ```bash # Personal ls ~/.claude/skills/my-skill/SKILL.md

# Project ls .claude/skills/my-skill/SKILL.md ```

1. Zwaliduj frontmatter YAML:
2. Pierwsza linia musi być dokładnie ---
3. Zamykające --- przed zawartością markdown
4. Brak tabulatorów w YAML (używaj spacji)

5. Pole name zawiera tylko małe litery z myślnikami

6. Uruchom w trybie debugowania: bash claude --debug # Watch for skill loading messages

Skill aktywuje się nieoczekiwanie:

Zawęź opis. Jeśli Twój skill aktywuje się, gdy nie powinien, opis jest zbyt szeroki:

# Too broad - activates on any "code" mention
description: Help with code

# Specific - activates only for security contexts
description: Audit code for security vulnerabilities including injection attacks, authentication flaws, and data exposure. Use when specifically asked about security, vulnerabilities, or when reviewing code for security issues.

Pliki pomocnicze nie znalezione:

• Używaj ścieżek względnych od lokalizacji SKILL.md
• Tylko ukośniki w przód (nawet na Windows)
• Sprawdź, czy plik faktycznie istnieje: ls .claude/skills/my-skill/REFERENCED.md

Kiedy tworzyć skill

Utwórz skill, gdy: - Wiedza domenowa powinna być automatycznie dostępna - Wielu członków zespołu potrzebuje tej samej wiedzy - Wielokrotnie wyjaśniasz te same wzorce lub zasady - Kontekst powinien być wstrzykiwany bez jawnego wywoływania - Wiedza obejmuje wiele plików i wymaga organizacji

Nie twórz skilla, gdy: - Chcesz jawnej kontroli nad wywoływaniem (użyj slash command) - Zadanie wymaga osobnego kontekstu (użyj subagent) - To jednorazowy prompt (po prostu go wpisz) - „Skill” to tak naprawdę pojedynczy szablon (użyj slash command)

Wskazówka eksperta: Jeśli zauważysz, że wielokrotnie wpisujesz /security-review przed pracą nad kodem autoryzacji, przekonwertuj to na skill. Wiedza powinna być otaczająca, nie jawnie wywoływana. Jeśli chcesz jawnego wywoływania, zachowaj to jako command.

System wtyczek

Wtyczki pakują rozszerzenia Claude Code do dystrybucji. Wtyczka może zawierać niestandardowe polecenia, subagenty, umiejętności, hooki i serwery MCP. Anthropic oficjalnie uruchomił marketplace wtyczek w grudniu 2025 roku z 36 wyselekcjonowanymi wtyczkami.⁴⁷

Struktura wtyczki

my-plugin/
├── .claude-plugin/
│   └── plugin.json              # Required: metadata
├── commands/                     # Slash commands
│   └── hello.md
├── agents/                       # Subagents
│   └── helper.md
├── skills/                       # Skills
│   └── my-skill/
│       └── SKILL.md
├── hooks/                        # Event handlers
│   └── hooks.json
└── .mcp.json                     # MCP servers

Manifest wtyczki

Minimalny plugin.json:

{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

Zarządzanie wtyczkami

> /plugin                              # Interactive interface
> /plugin install name@marketplace     # Install
> /plugin enable name@marketplace      # Enable
> /plugin disable name@marketplace     # Disable
> /plugin uninstall name@marketplace   # Remove
> /plugin marketplace add ./local      # Add local marketplace
> /plugin marketplace list             # View marketplaces

Lokalne tworzenie wtyczek

Tworzenie lokalnego marketplace do testowania:

mkdir dev-marketplace && cd dev-marketplace
mkdir my-plugin
# Create plugin structure

cd ..
claude
> /plugin marketplace add ./dev-marketplace
> /plugin install my-plugin@dev-marketplace

Komponenty wtyczki

• Commands: Dostępne jako polecenia slash (/plugin-command)
• Agents: Pojawiają się na liście /agents
• Skills: Ładują się automatycznie na podstawie konfiguracji umiejętności
• Hooks: Łączone z hookami użytkownika/projektu, uruchamiane równolegle
• MCP Servers: Uruchamiane automatycznie po włączeniu wtyczki

Jak działa pamięć?

System pamięci Claude Code umożliwia trwały kontekst między sesjami. Efektywne zarządzanie pamięcią to różnica między głębokim rozumieniem projektu przez Claude a traktowaniem każdej sesji jako zupełnie nowej.

Hierarchia CLAUDE.md

Efektywna struktura CLAUDE.md

# Project Context

## Architecture
- Monorepo with packages in /packages
- React frontend in /packages/ui
- Node.js API in /packages/api
- Shared types in /packages/types
- PostgreSQL database via Prisma

## Code Standards
- TypeScript strict mode everywhere
- ESLint + Prettier enforced (pre-commit hooks)
- No default exports
- JSDoc on all public APIs
- Tests required for all new code

## Commands
- `npm test` - Run all tests
- `npm run test:watch` - Watch mode
- `npm run lint` - Check linting
- `npm run lint:fix` - Auto-fix lint issues
- `npm run build` - Production build
- `npm run dev` - Start dev servers
- `npm run db:migrate` - Run migrations
- `npm run db:seed` - Seed database

## Patterns

### API Endpoints
Create in packages/api/src/routes/
Use Zod for request/response validation
All endpoints need OpenAPI documentation

### React Components
Create in packages/ui/src/components/
Use React Query for server state
Prefer composition over inheritance

### Database
Prisma schema in packages/api/prisma/
Always create migration for schema changes
Use transactions for multi-table operations

## Important Notes
- NEVER commit .env files
- API runs on :3000, UI on :3001
- Local DB: postgres://localhost:5432/myapp
- Feature flags in packages/api/src/flags.ts

## Recent Decisions
- 2025-12-01: Migrated to React Query v5
- 2025-11-15: Adopted Zod for all validation
- 2025-11-01: Moved to ESM modules

# Summary Instructions
When using compact, focus on:
- Recent code changes
- Test results
- Architecture decisions made this session

Importowanie plików

Odwoływanie się do innych plików w CLAUDE.md:

See @README.md for project overview
Coding standards: @docs/STYLE_GUIDE.md
API documentation: @docs/API.md
Personal preferences: @~/.claude/preferences.md

Składnia importu: - Względna: @docs/file.md - Bezwzględna od projektu: @/absolute/path.md - Katalog domowy: @~/.claude/file.md - Maksymalna głębokość: 5 poziomów importów

Katalog reguł pamięci

Dla lepszej organizacji pamięci można użyć .claude/rules/ do przechowywania skategoryzowanych plików reguł:¹⁸

.claude/rules/
├── testing.md          # Testing conventions
├── security.md         # Security requirements
├── api-patterns.md     # API design patterns
└── deployments.md      # Deployment procedures

Reguły ładują się automatycznie i zapewniają ustrukturyzowany kontekst bez zaśmiecania CLAUDE.md.

Szybkie dodawanie do pamięci

Prefiks # służy do dodawania notatek podczas sesji:

# Always run tests before committing
# The payment module is especially fragile
# Use the new logger from packages/api/src/logger.ts

Zostanie wyświetlony monit o wybór pliku pamięci, w którym notatka ma być zapisana.

Polecenia zarządzania kontekstem

Wyświetlanie użycia kontekstu:

> /context

Pokazuje wizualną siatkę alokacji kontekstu w prompt systemowy, konwersację, narzędzia i zawartość plików.

Kompaktowanie konwersacji:

> /compact
> /compact focus on the authentication changes
> /compact preserve test output and error messages

Inteligentnie podsumowuje starszą konwersację, zachowując kluczowe informacje.

Niestandardowe instrukcje kompaktowania (w CLAUDE.md):

# Summary Instructions
When using compact, focus on:
- Test output and failures
- Code changes made this session
- Architecture decisions

Rozszerzone myślenie dla kontekstu:

export MAX_THINKING_TOKENS=10000

Więcej tokenów myślenia oznacza większą zdolność rozumowania, ale wyższe koszty.

Strategie optymalizacji kontekstu

1. Używanie konkretnych odwołań do plików zamiast proszenia Claude o wyszukiwanie
2. Czyszczenie niepowiązanych konwersacji poleceniem /clear między zadaniami
3. Proaktywne kompaktowanie podczas długich sesji
4. Używanie subagentów do izolowania pracy eksploracyjnej
5. Dzielenie złożonych zadań na skoncentrowane interakcje
6. Wznawianie sesji dla bieżącej pracy zamiast ponownego wyjaśniania

Obrazy i dane multimodalne

Claude Code może analizować obrazy — zrzuty ekranu, diagramy, makiety, komunikaty o błędach, schematy baz danych.

Metody wprowadzania

1. Przeciągnij i upuść: Przeciągnięcie plików graficznych do okna Claude Code
2. Wklej: Ctrl+V (nie Cmd+V na Mac) do wklejania ze schowka
3. Odwołanie do ścieżki: „Przeanalizuj ten obraz: /path/to/screenshot.png”

Wyświetlanie załączonych obrazów

Gdy Claude odwołuje się do obrazu w odpowiedzi, klikalne linki do obrazów umożliwiają bezpośrednie wyświetlanie:³⁴

[Image #1]   # Click to open in default image viewer
[Image #2]   # Navigate attached screenshots

Jest to przydatne podczas przeglądania zrzutów ekranu lub debugowania problemów wizualnych — wystarczy kliknąć odwołanie, aby zobaczyć dokładnie to, co przeanalizował Claude.

Przypadki użycia

• Debugowanie problemów UI: „Oto zrzut ekranu błędu, co go powoduje?”
• Implementacja projektów: „Zbuduj ten komponent na podstawie makiety”
• Analiza diagramów: „Wyjaśnij ten diagram architektury”
• Schematy baz danych: „Utwórz modele Prisma pasujące do tego ERD”
• Analiza błędów: „Co oznacza ten zrzut ekranu z błędem?”

Wskazówka eksperta: Podczas implementacji z makiet warto dołączyć wiele zrzutów ekranu pokazujących różne stany (domyślny, najechanie, ładowanie, błąd). Im więcej kontekstu wizualnego, tym lepsza implementacja.

Jak działa integracja z Git?

Claude Code ma głęboką integrację z git z wbudowanymi protokołami bezpieczeństwa.

Protokoły bezpieczeństwa

• Automatyczne respektowanie .gitignore
• Brak modyfikacji gałęzi bez pozwolenia
• Pokazywanie różnic przed commitami
• Przestrzeganie konwencji commitów projektu
• Nigdy nie wykonuje force push bez wyraźnej prośby
• Sprawdzanie autorstwa przed poprawianiem commitów

Typowe przepływy pracy

Tworzenie commitów:

> commit these changes
> create a commit with a meaningful message

Claude: 1. Uruchomi git status i git diff 2. Przeanalizuje zmiany 3. Wygeneruje konwencjonalny komunikat commita 4. Poczeka na zatwierdzenie przed wykonaniem commita

Tworzenie pull requestów:

> create a PR for this feature
> summarize the changes and create a PR

Przegląd kodu:

> review the changes in this PR
> what could go wrong with these changes?

Integracja z GitHub Actions

Automatyzacja Claude w CI/CD za pomocą oficjalnej akcji:

Szybka konfiguracja:

> /install-github-app

Ręczny plik workflow:

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: "Review this PR for bugs, security issues, and performance problems"
          claude_args: "--max-turns 5"

Dla Bedrock (z OIDC):

- name: Configure AWS
  uses: aws-actions/configure-aws-credentials@v4
  with:
    role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
    aws-region: us-west-2

- uses: anthropics/claude-code-action@v1
  with:
    use_bedrock: "true"
    claude_args: '--model us.anthropic.claude-sonnet-4-5-20250929-v1:0'

Jak używać Claude Code w IDE?

Rozszerzenie VS Code

Wymagania: VS Code 1.98.0+

Instalacja: Wyszukanie „Claude Code” w marketplace rozszerzeń

Funkcje: - Panel boczny (ikona Spark) - Tryb planowania z podglądem różnic - Przełącznik automatycznego akceptowania edycji - Przełącznik rozszerzonego myślenia - Załączanie plików i wklejanie obrazów - Historia konwersacji - Wiele jednoczesnych sesji

Uwaga dotycząca bezpieczeństwa: Luka w obejściu uwierzytelniania WebSocket (CVE-2025-52882) została załatana w rozszerzeniach IDE w wersji 1.0.24+. Należy upewnić się, że rozszerzenie jest zaktualizowane — wszystkie podatne wersje zostały usunięte ze sklepów z rozszerzeniami.³⁸

Konfiguracja zewnętrznego dostawcy (w .claude/settings.json):

{
  "env": {
    "CLAUDE_CODE_USE_BEDROCK": "1",
    "AWS_REGION": "us-east-1",
    "AWS_PROFILE": "your-profile"
  }
}

Wtyczka JetBrains

Obsługiwane: IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, DataGrip

Instalacja: Settings → Plugins → Wyszukanie „Claude Code” → Install → Restart

Kluczowe skróty: - Cmd+Esc (Mac) / Ctrl+Esc (Windows): Szybkie uruchomienie - Cmd+Option+K (Mac) / Alt+Ctrl+K (Windows): Dodanie odwołania do pliku

Funkcje: - Wyświetlanie różnic w przeglądarce różnic IDE - Automatyczne udostępnianie kontekstu zaznaczenia - Integracja diagnostyczna - Wiele sesji

Konfiguracja WSL2: Ustawienie polecenia Claude na:

wsl -d Ubuntu -- bash -lic "claude"

Integracja z terminalem

Połączenie zewnętrznego terminala z IDE:

> /ide

Claude Code automatycznie wykrywa VS Code, Cursor, Windsurf i IDE JetBrains.

Integracja ze Slack (grudzień 2025)

Claude Code integruje się teraz bezpośrednio ze Slack, umożliwiając programistom delegowanie zadań kodowania z wątków czatu.¹⁴

Jak to działa: 1. Wzmianka @Claude w kanale lub wątku Slack 2. Claude analizuje wiadomość, aby określić, czy jest to zadanie kodowania 3. Sesja Claude Code automatycznie uruchamia się na infrastrukturze Anthropic 4. Claude zbiera kontekst z ostatnich wiadomości kanału/wątku 5. Aktualizacje postępu są publikowane z powrotem do wątku Slack 6. Linki do przeglądu zmian i otwierania PR są udostępniane po zakończeniu

Przypadki użycia: - Badanie błędów na podstawie raportów błędów publikowanych w Slack - Szybkie przeglądy kodu na podstawie opinii zespołu - Małe implementacje funkcji na podstawie zgłoszeń funkcji

Wymagania: - Aplikacja Claude zainstalowana przez Slack App Marketplace - Płatny plan Slack - Dostęp do Claude Code w przeglądarce

Prywatność: Claude respektuje istniejącą strukturę uprawnień Slack. Nie ma dostępu do konwersacji ani repozytoriów, do których użytkownik nie jest uprawniony. Konwersacje nie są wykorzystywane do trenowania modelu.

Zaawansowane wzorce użytkowania

Tryb bezobsługowy i CI

Uruchamianie Claude Code w skryptach i potokach CI:

#!/bin/bash
# Automated code review

result=$(claude -p "Review this code for quality issues" \
  --output-format json \
  --allowedTools "Read,Grep,Glob" \
  --permission-mode plan \
  --disable-slash-commands \
  --max-turns 5)

if echo "$result" | jq -e '.result | test("critical|high severity")' > /dev/null; then
  echo "Issues found:"
  echo "$result" | jq -r '.result'
  exit 1
fi

echo "Review passed"
exit 0

Potokowanie i łączenie poleceń

# Analyze logs
cat production.log | claude -p "summarize errors" > error-summary.md

# Process multiple files
find . -name "*.ts" -exec cat {} \; | claude -p "find security issues"

# Chain with jq
claude -p "generate config" --output-format json | jq -r '.result' > config.json

Zadania w tle

Uruchamianie długich operacji bez blokowania:

> start the build in the background

Można również nacisnąć Ctrl+B podczas wykonywania polecenia.

Zarządzanie zadaniami w tle:

> /bashes                    # List running tasks
> get output from task xyz   # Retrieve output

Równoległe sesje z git worktrees

# Create worktrees for parallel work
git worktree add ../project-feature-a -b feature-a
git worktree add ../project-bugfix bugfix-123

# Run Claude in each
cd ../project-feature-a && claude --session-id "feature-a"
cd ../project-bugfix && claude --session-id "bugfix-123"

Każde worktree jest niezależnym katalogiem projektu z własną sesją.

Parsowanie wyników JSON

result=$(claude -p "analyze this code" --output-format json)

# Extract fields
echo "Result: $(echo $result | jq -r '.result')"
echo "Cost: $(echo $result | jq -r '.total_cost_usd')"
echo "Session: $(echo $result | jq -r '.session_id')"
echo "Duration: $(echo $result | jq -r '.duration_ms')ms"

Programowe zarządzanie sesjami

# Named sessions for tracking
claude --session-id "feature-$(git branch --show-current)-$(date +%s)"

# Continue previous work
claude -c "continue implementing the tests"

# Fork for parallel exploration
claude -r "main-session" --fork-session "try alternative approach"

Czym jest Claude Code Remote?

Claude Code Remote łączy środowisko webowe z terminalem, umożliwiając rozpoczęcie zadań w chmurze i kontynuowanie ich lokalnie — lub odwrotnie. Ta funkcja zmienia sposób pracy na różnych urządzeniach.

Podstawowa koncepcja

Interfejs webowy pod adresem claude.ai/code uruchamia Claude Code w chmurze. Zadania wykonują się w tle, gdy użytkownik jest z dala od terminala. Gdy nadejdzie pora, aby kontynuować, można teleportować sesję na maszynę lokalną i podjąć pracę dokładnie tam, gdzie Claude ją przerwał.

Umożliwia to przepływy pracy, które wcześniej nie były możliwe: - Rozpoczęcie złożonego refaktoringu z telefonu, kontynuacja podczas dojazdu, a następnie zakończenie na stacji roboczej - Kolejkowanie wielu zadań w interfejsie webowym i przeglądanie wyników po powrocie do biurka - Przekazanie długotrwałych operacji do chmury, gdy trzeba zamknąć laptop

Prefiks &

Wysyłanie zadania do uruchomienia w tle na Claude Code web:

& Build a comprehensive REST API for user management with authentication, CRUD operations, and proper error handling

Prefiks & wysyła polecenie do chmury. Claude pracuje nad nim asynchronicznie — można zamknąć terminal, zmienić urządzenie lub kontynuować inną pracę. Interfejs webowy pod adresem claude.ai/code pokazuje uruchomione i zakończone sesje.

Flaga --teleport

Przeniesienie sesji z chmury do lokalnego terminala:

claude --teleport session_abc123

To polecenie pobiera stan sesji z chmury i wznawia ją lokalnie. Użytkownik otrzymuje pełną historię konwersacji, wszystkie pliki zmodyfikowane przez Claude i może kontynuować interakcję tak, jakby był obecny przez cały czas.

Identyfikator sesji jest widoczny w interfejsie webowym. Wystarczy kliknąć dowolną sesję, aby zobaczyć jej identyfikator i aktualny status.

Wymagania

Claude Code Remote jest dostępny dla subskrybentów planów Pro, Max, Team (stanowiska premium) i Enterprise (stanowiska premium).⁷³ Interfejs webowy działa na infrastrukturze Anthropic, wykonując te same funkcje Claude Code, które są dostępne lokalnie — operacje na plikach, polecenia bash, integracje MCP — ale w zarządzanym środowisku chmurowym. Dostęp dla planów Team i Enterprise został rozszerzony w styczniu 2026 — administratorzy kont mogą włączyć dostęp w ustawieniach Claude.

Aplikacja iOS (listopad 2025): Claude Code jest również dostępny w aplikacji Claude na iOS, co umożliwia uruchamianie zadań programistycznych w podróży i monitorowanie postępu agenta z telefonu.²² Można rozpocząć zadania poza biurkiem, a później teleportować je do terminala, gdy nadejdzie pora na przegląd.

Praktyczny przepływ pracy

Poranny dojazd:

& Review all PRs assigned to me and prepare summaries with recommendations

Przy biurku:

# Check what completed
# Visit claude.ai/code to see session list

# Pull the session locally to review and act on recommendations
claude --teleport pr-review-session-xyz

Przed wyjściem z pracy:

& Run the full test suite, fix any failures, and prepare a summary of what was changed

Następnego ranka:

claude --teleport test-fixes-session-abc
# Review what Claude did overnight, make final adjustments

Aktualny status

Claude Code Remote jest obecnie w wersji zapoznawczej (research preview). Należy oczekiwać, że funkcja będzie ewoluować w miarę zbierania opinii przez Anthropic. Podstawowy przepływ pracy — wykonanie w chmurze z lokalną teleportacją — umożliwia ciągłe programowanie z AI: Claude pracuje, gdy użytkownik jest z dala od klawiatury, a po powrocie można podjąć pracę dokładnie tam, gdzie została przerwana.

Obecne ograniczenie: Teleportacja sesji jest obecnie jednokierunkowa — można przenosić sesje webowe do terminala, ale nie można przesłać istniejącej sesji terminalowej do chmury. Nie ma jeszcze możliwości kontynuowania lokalnej sesji na zdalnej maszynie (np. instancji AWS przez SSH).

Czym są agenci działający w tle?

Agenci działający w tle pracują, podczas gdy użytkownik kontynuuje swoją pracę — bez czekania na zakończenie długotrwałych zadań.¹⁷

Jak działają agenci w tle

Zamiast blokować terminal podczas wykonywania złożonego zadania przez Claude, agenci w tle: 1. Wykonują się niezależnie w osobnym procesie 2. Kontynuują pracę nawet po zamknięciu terminala 3. Zgłaszają wyniki po zakończeniu za pomocą powiadomienia 4. Mogą być monitorowani i zarządzani w trakcie działania

Uruchamianie agenta w tle

Za pomocą Ctrl+B: Gdy Claude pracuje, naciśnięcie Ctrl+B przenosi bieżące zadanie do tła. Terminal staje się natychmiast dostępny.

Za pomocą prefiksu &:

& Run all tests and fix any failures
& Refactor the authentication module to use JWT
& Generate comprehensive API documentation

Prefiks & wysyła zadanie do Claude Code Remote (wykonanie w chmurze). W przypadku lokalnego wykonania w tle należy użyć Ctrl+B na już uruchomionym zadaniu.

Monitorowanie zadań w tle

> /tasks                    # List all running tasks
> /task status abc123       # Check specific task
> /task cancel abc123       # Stop a task
> /task output abc123       # View task output so far

Równoległe przepływy pracy w tle

Uruchamianie wielu agentów jednocześnie:

& Fix all failing tests in src/
& Update documentation for the API module
& Run security scan on the codebase

Każdy działa niezależnie. Postęp można monitorować za pomocą /tasks, a wyniki pobierać w miarę ich ukończenia.

Claude in Chrome (grudzień 2025)

Claude Code integruje się teraz z przeglądarką za pomocą rozszerzenia Claude in Chrome, umożliwiając bezpośrednie sterowanie przeglądarką z terminala.²⁴

Konfiguracja

1. Zainstaluj rozszerzenie Chrome ze strony https://claude.ai/chrome
2. Uruchom Claude Code — integracja zostanie automatycznie wykryta
3. Używaj języka naturalnego do sterowania przeglądarką

Możliwości

Automatyzacja przeglądarki z terminala:

> Navigate to github.com and open my repositories
> Fill out this form with the test user data
> Take a screenshot of the current page
> Click the submit button and wait for the page to load

Scraping stron i testowanie:

> Extract all product prices from this e-commerce page
> Run through the signup flow and report any issues
> Check if the mobile menu works correctly

Zastosowania

• Testy E2E: Uruchamianie testów integracyjnych bezpośrednio z Claude Code
• Scraping stron: Wyodrębnianie danych ze stron bez pisania kodu automatyzacji przeglądarki
• Wypełnianie formularzy: Automatyzacja powtarzalnych przepływów pracy w przeglądarce
• Weryfikacja wizualna: Zrzuty ekranu i analiza układów stron

Integracja z Chrome działa w ramach istniejącej sesji przeglądarki, mając dostęp do stanu zalogowania i plików cookie — co jest przydatne przy testowaniu przepływów wymagających uwierzytelnienia.

Claude Code in Slack (grudzień 2025)

Anthropic uruchomił Claude Code in Slack, umożliwiając programistom delegowanie zadań programistycznych bezpośrednio z wątków czatu.²⁶

Jak to działa

1. Oznacz @Claude w dowolnym kanale lub wątku Slack
2. Opisz zadanie programistyczne z odpowiednim kontekstem
3. Claude analizuje wiadomości Slack, aby określić repozytorium
4. Aktualizacje postępu pojawiają się w wątku
5. Claude udostępnia linki do przeglądu pracy i otwartych PR-ów

Przykładowy przepływ pracy

@Claude The login form validation is broken on mobile devices.
Can you fix it? Check the bug report from earlier in this thread.

Claude wykona następujące kroki: 1. Przeczyta wątek w celu uzyskania kontekstu 2. Zidentyfikuje odpowiednie repozytorium 3. Sklonuje i przeanalizuje bazę kodu 4. Opublikuje aktualizacje postępu 5. Utworzy PR z poprawką 6. Udostępni link do PR w celu przeglądu

Korzyści

• Świadomość kontekstu: Claude czyta historię Slack w poszukiwaniu zgłoszeń błędów, żądań funkcji i dyskusji
• Widoczność dla zespołu: Aktualizacje postępu w wątkach informują wszystkich na bieżąco
• Niski próg wejścia: Nie jest wymagany terminal ani IDE — wystarczy rozpocząć z poziomu czatu
• Integracja z GitHub: PR-y tworzone automatycznie z odpowiednimi opisami

Wymagania

• Przestrzeń robocza Slack z włączoną integracją Claude
• Połączone repozytorium GitHub
• Odpowiednie uprawnienia dla Claude do tworzenia gałęzi i PR-ów

Ta funkcja jest obecnie w wersji zapoznawczej (research preview) dla użytkowników planów Pro, Max, Team i Enterprise.

Ile kosztuje Claude Code?

Zrozumienie i kontrolowanie kosztów jest niezbędne do zrównoważonego korzystania z Claude Code.

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

Plany subskrypcji

Limity wykorzystania (sierpień 2025): Anthropic wprowadził tygodniowe limity dla płatnych subskrybentów. Subskrybenci Max mogą dokupić dodatkowe wykorzystanie powyżej limitu według standardowych stawek API.²¹

Cennik tokenów API (styczeń 2026)⁵⁷

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

Buforowanie promptów znacząco obniża koszty powtarzających się danych wejściowych: zapis do pamięci podręcznej kosztuje 1,25× ceny bazowej (pamięć 5-min) lub 2× (pamięć 1-godz.), ale odczyt z pamięci podręcznej kosztuje tylko 0,1× — oszczędność 90%. Dla systemów RAG i asystentów kodowania z powtarzającym się kontekstem, buforowanie może obniżyć koszty o 88-95%.

Batch API oferuje 50% zniżki z 24-godzinnym czasem realizacji dla zadań niewymagających natychmiastowej odpowiedzi, takich jak nocne zestawy testów.

Polityka dotycząca wielu kont⁵⁹

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

Co jest dozwolone:

Ograniczenia techniczne: - Do 3 kont można zweryfikować tym samym numerem telefonu - Wiele płatnych subskrypcji z tego samego IP/sieci jest wyraźnie wspierane - Konta są całkowicie oddzielone — brak możliwości przenoszenia czatów lub projektów między nimi

Co jest zabronione (zgodnie z Polityką użytkowania): - Tworzenie kont w celu obejścia blokad po otrzymaniu bana - Koordynowanie złośliwych działań między kontami w celu uniknięcia wykrycia - Używanie wielu kont do obchodzenia limitów lub darmowych kredytów

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

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

Czynniki wpływające na koszty

Przykłady kosztów z praktyki

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

Zarządzanie kosztami zespołu

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

Ukryte opłaty za narzędzia

Oprócz cennika za token, niektóre narzędzia wiążą się z oddzielnymi opłatami:¹⁶

Te opłaty sumują się w pętlach agentów. 100-iteracyjny cykl debugowania z Bash kosztuje ~24 500 dodatkowych tokenów wejściowych samego narzutu.

Strategie oszczędzania kosztów

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

Monitorowanie wykorzystania

• Claude Console: platform.claude.com (wymaga roli Admin lub Billing)
• Limity workspace: Ustaw limity wydatków na workspace
• Bedrock/Vertex: Używaj natywnego monitorowania kosztów chmury
• LiteLLM: Do szczegółowego śledzenia per użytkownik z dostawcami zewnętrznymi

Wykorzystanie tokenów w tle

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

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

Claude Code Analytics API (Team/Enterprise)⁵³

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

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

Optymalizacja wydajności

Zmniejszanie opóźnień

Wybór modelu: - Haiku: Najszybsze odpowiedzi, najniższy koszt - Sonnet: Dobra równowaga - Opus: Najlepsza jakość, najwyższe opóźnienia

Streaming: Wszystkie odpowiedzi są domyślnie strumieniowane — widać dane wyjściowe w miarę ich generowania.

Buforowanie promptów: Domyślnie włączone. Zmniejsza opóźnienia dla powtarzającego się kontekstu (prompty systemowe, definicje narzędzi).

Strategie buforowania

Prompty systemowe i definicje narzędzi są automatycznie buforowane: - Czas przechowywania w pamięci podręcznej: 5 minut (efemeryczny) - Trafienie w pamięć podręczną: Zmniejszona liczba tokenów wejściowych i szybsza odpowiedź

Bloki myślenia z poprzednich tur są buforowane w konwersacjach wieloturowych.

W razie potrzeby można wyłączyć buforowanie dla poszczególnych modeli:

export DISABLE_PROMPT_CACHING_SONNET=1
export DISABLE_PROMPT_CACHING_OPUS=1
export DISABLE_PROMPT_CACHING_HAIKU=1

Operacje równoległe

Równoległość subagentów: Wiele subagentów może działać jednocześnie. Każdy działa niezależnie bez zanieczyszczania głównego kontekstu.

Bash w tle: Długotrwałe polecenia nie blokują konwersacji:

> run the full test suite in the background

Git worktrees: Umożliwiają prawdziwe równoległe sesje na oddzielnych gałęziach.

Optymalizacja pamięci

• Konkretne odwołania do plików: @src/auth.ts zamiast „znajdź plik auth”
• Ukierunkowane wyszukiwania: „szukaj w src/api” zamiast „szukaj wszędzie”
• Świeże sesje: /clear między niepowiązanymi zadaniami
• Niestandardowa kompakcja: Dodaj instrukcje do CLAUDE.md określające, co zachować

Jak debugować problemy?

Problemy z instalacją

Problemy ze ścieżką WSL:

npm config set os linux
npm install -g @anthropic-ai/claude-code --force --no-os-check
which npm  # Powinno zaczynać się od /usr, nie /mnt/c

Konflikty wersji Node (nvm): Dodaj do ~/.bashrc lub ~/.zshrc:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

Błędy uprawnień: Użyj natywnej instalacji zamiast npm:

curl -fsSL https://claude.ai/install.sh | bash

Problemy z uwierzytelnianiem

# Pełny reset
/logout
rm -rf ~/.config/claude-code/auth.json
claude  # Świeże logowanie

Problemy z wydajnością

Wysokie zużycie CPU/pamięci: - Użyj /compact, aby zmniejszyć kontekst - Restartuj między większymi zadaniami - Dodaj duże katalogi do .gitignore - Uruchom claude doctor

Wolne wyszukiwanie: Zainstaluj systemowy ripgrep:

# macOS
brew install ripgrep

# Windows
winget install BurntSushi.ripgrep.MSVC

# Linux
sudo apt install ripgrep

Następnie:

export USE_BUILTIN_RIPGREP=0

Wolne działanie na WSL: - Przenieś projekt do systemu plików Linux (nie /mnt/c/) - Używaj konkretnych filtrów katalogów w wyszukiwaniach

Problemy z integracją IDE

JetBrains nie wykrywany (WSL2):

Opcja 1 - Zapora Windows:

wsl hostname -I  # Pobierz IP WSL
New-NetFirewallRule -DisplayName "Allow WSL2" -Direction Inbound -Protocol TCP -Action Allow -RemoteAddress 172.21.0.0/16

Opcja 2 - Sieć lustrzana (dodaj do ~/.wslconfig):

[wsl2]
networkingMode=mirrored

Następnie: wsl --shutdown

Klawisz Escape nie działa w JetBrains: Settings → Tools → Terminal → Odznacz „Move focus to the editor with Escape”

Tryb debugowania

claude --debug                    # Pełne dane debugowania
ANTHROPIC_LOG=debug claude       # Logowanie żądań API
claude doctor                    # Sprawdzenie stanu

Reset konfiguracji

# Reset ustawień użytkownika
rm ~/.claude.json
rm -rf ~/.claude/

# Reset ustawień projektu
rm -rf .claude/
rm .mcp.json

Typowe komunikaty o błędach

Wdrażanie w przedsiębiorstwie

Porównanie dostawców chmurowych

Wdrażanie ustawień zarządzanych

Wdrażanie zasad obowiązujących w całej organizacji za pomocą managed-settings.json:

Lokalizacja: - macOS: /Library/Application Support/ClaudeCode/managed-settings.json - Linux: /etc/claude-code/managed-settings.json - Windows: C:\Program Files\ClaudeCode\managed-settings.json

Przykładowa polityka:

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm run:*)",
      "Bash(git:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(curl:*)",
      "Read(.env*)",
      "WebFetch"
    ],
    "defaultMode": "default"
  },
  "model": "claude-sonnet-4-5-20250929",
  "disableBypassPermissionsMode": "disable"
}

Użytkownicy nie mogą nadpisać ustawień zarządzanych.

Korporacyjny plik CLAUDE.md

Wdrażanie kontekstu obowiązującego w całej organizacji:

Lokalizacja: - macOS: /Library/Application Support/ClaudeCode/CLAUDE.md - Linux: /etc/claude-code/CLAUDE.md

Zawartość:

# Company Standards

## Security Requirements
- Never commit secrets or credentials
- All external API calls require security review
- Use parameterized queries for all database access

## Code Standards
- Follow company style guide at @docs/STYLE.md
- All PRs require two approvals
- Test coverage minimum: 80%

## Approved Tools
- npm, yarn, pnpm for package management
- Jest for testing
- ESLint + Prettier for formatting

Strategia wdrażania

1. Rozpoczęcie od dokumentacji: należy dopracować plik CLAUDE.md przed wdrożeniem
2. Grupa pilotażowa: rozpoczęcie z 5–10 programistami
3. Faza pytań i odpowiedzi: umożliwienie pilotom korzystania z Claude do eksploracji kodu
4. Rozwój z przewodnikiem: przejście do drobnych poprawek błędów
5. Pełne wdrożenie: uruchomienie z ustawieniami zarządzanymi
6. Monitorowanie kosztów: śledzenie wykorzystania w poszczególnych zespołach

Audyt i zgodność

• Transkrypcje sesji są domyślnie przechowywane lokalnie
• W przypadku audytu korporacyjnego należy korzystać z logowania dostawcy chmurowego
• Warto rozważyć LiteLLM do szczegółowego śledzenia wykorzystania
• Ustawienia zarządzane wymuszają polityki zgodności

Analytics API (Administrator)

Plany Enterprise i Team zapewniają dostęp do Claude Code Analytics API umożliwiającego programowe śledzenie wykorzystania.

Endpoint: GET /v1/organizations/usage_report/claude_code

Uwierzytelnianie: Wymaga klucza Admin API (sk-ant-admin...), provisionowanego w konsoli przez administratorów organizacji.

Dostępne metryki:

Parametry żądania: - starting_at – data do dziennej agregacji (RRRR-MM-DD) - Zwraca dane na poziomie użytkownika za określony dzień

Przykład:

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

Ograniczenia: - Wyłącznie agregaty dzienne (ok. 1 godziny opóźnienia dla zapewnienia spójności) - Do monitorowania w czasie rzeczywistym należy korzystać z integracji OpenTelemetry - Śledzi wyłącznie wykorzystanie API 1st party (nie Bedrock/Vertex)

Koszt: Bezpłatne dla organizacji z dostępem do Admin API.

Skróty klawiszowe – informacje

Ogólne sterowanie

Konfigurowalne skróty klawiszowe (od wersji 2.1.18): Polecenie /keybindings umożliwia dostosowanie skrótów klawiszowych. Obsługiwane są powiązania zależne od kontekstu, sekwencje akordy (kombinacje wieloklawiszowe) oraz pełna personalizacja. Skróty są przechowywane w ~/.claude/keybindings.json. Pełna dokumentacja konfiguracji jest dostępna w dokumentacji keybindings.⁷⁷

Sugestie promptów (grudzień 2025): Claude sugeruje teraz prompty przyspieszające pracę. Naciśnięcie Tab akceptuje sugestię, a Enter pozwala wprowadzić własny prompt.¹³

Wprowadzanie wieloliniowe

Szybkie prefiksy

Wydajność odwołań do plików (styczeń 2026): Wzmianki @ działają teraz 3 razy szybciej w repozytoriach git. Claude Code respektuje również pliki .ignore i .rgignore podczas sugerowania uzupełnień plików — przydatne do wykluczania artefaktów kompilacji lub plików generowanych z sugestii.³⁵

Tryb Vim

Aktywacja poleceniem /vim:

Tryb normalny: - h/j/k/l – nawigacja - w/e/b – poruszanie się po słowach - 0/$ – początek/koniec linii - gg/G – początek/koniec bufora - dd – usunięcie linii - cc/C – zmiana linii/do końca - dw/de/db – warianty usuwania słów - x – usunięcie znaku - . – powtórzenie ostatniej edycji

Tryb wstawiania: - i/I – wstawianie przed/na początku linii - a/A – wstawianie po/na końcu linii - o/O – otwarcie linii poniżej/powyżej - Esc – powrót do trybu normalnego

Najlepsze praktyki

Strategia sesji

Używanie opisowych identyfikatorów sesji:

claude --session-id "feature-$(git branch --show-current)-$(date +%s)"
claude --session-id "bug-JIRA-456"
claude --session-id "spike-new-architecture"

Wznawianie sesji w przypadku kontynuacji pracy zamiast ponownego wyjaśniania kontekstu.

Projektowanie pliku CLAUDE.md

Dbałość o czytelność. Claude odczytuje ten plik przy każdej sesji — gęsty tekst marnuje kontekst.

Skupienie się na tym, co nieoczywiste. Dokumentowanie wzorców specyficznych dla projektu, nietypowych konwencji i decyzji. Pomijanie tego, co Claude może wywnioskować z kodu.

Ciągła aktualizacja. Dodawanie notatek podczas programowania za pomocą #. Cotygodniowy przegląd i konsolidacja.

Dołączenie opisu poleceń. Polecenia używane na co dzień powinny być udokumentowane.

Polecenia niestandardowe

Tworzenie poleceń dla powtarzalnych procesów:

---
description: Start new feature
allowed-tools: Bash(git:*), Read, Edit
---

1. Create branch: !`git checkout -b feature/$ARGUMENTS`
2. Pull latest main
3. Set up boilerplate
4. Begin implementation

Efektywne promptowanie

Precyzja:

# Dobrze
"Add email validation to LoginForm in src/components/LoginForm.tsx"

# Zbyt ogólne
"Improve the login"

Bezpośrednie odwołania do plików:

"Review @src/auth/middleware.ts for security issues"

Określanie ograniczeń:

"Refactor using the same pattern as @src/repositories/UserRepository.ts"

Korzystanie z subagents do eksploracji:

"Have an explore agent find all places where we handle errors"

Kontrola kosztów

• Regularne korzystanie z /cost
• Używanie modelu Haiku do prostych zadań i subagents
• Ustawianie MAX_THINKING_TOKENS tylko wtedy, gdy jest to potrzebne
• Używanie --max-turns w skryptach automatycznych
• Proaktywna kompaktacja w długich sesjach

Bezpieczeństwo

• Konfiguracja reguł odrzucania w .claude/settings.json dla wrażliwych plików
• Korzystanie z trybu sandbox dla niezaufanych projektów
• Nigdy nie zezwalać na Bash(rm -rf:*) ani Bash(sudo:*)
• Używanie hooks do blokowania dostępu do sekretów
• Wdrażanie ustawień zarządzanych w środowisku korporacyjnym

Wskazówki i techniki społeczności⁵⁶⁵⁸

Społeczność Claude Code odkryła potężne wzorce wykraczające poza oficjalną dokumentację. Te wskazówki pochodzą od zaawansowanych użytkowników, w tym Borisa Cherny’ego (twórcy Claude Code) oraz z repozytorium zawierającego ponad 40 porad.

Używanie trybu planowania przed kodowaniem

Jeśli można zapamiętać tylko jedną wskazówkę, niech będzie to ta. Im więcej czasu poświęci się na planowanie, tym większe prawdopodobieństwo sukcesu Claude. Naciśnięcie Shift+Tab przełącza do trybu planowania przed rozpoczęciem implementacji.

Nowość ze stycznia 2026: Po zaakceptowaniu planu Claude oferuje teraz automatyczne wyczyszczenie kontekstu, dając planowi świeże okno kontekstowe. To znacząco poprawia przestrzeganie planu — Claude dłużej trzyma się kursu bez zakłóceń ze strony starego kontekstu. Dostępne opcje to: „Tak, wyczyść kontekst i automatycznie akceptuj edycje” (Shift+Tab), „Tak, i ręcznie zatwierdzaj edycje” lub „Tak, automatycznie akceptuj edycje” (bez czyszczenia).

Częste czyszczenie kontekstu

Warto często używać /clear. Za każdym razem, gdy rozpoczyna się coś nowego, należy wyczyścić czat. Stara historia nie musi zużywać tokenów ani wywoływać kosztownych operacji kompaktowania. Wystarczy ją wyczyścić i przejść dalej.

Używanie obrazów i zrzutów ekranu

Claude doskonale radzi sobie z danymi wizualnymi. Na macOS: Cmd+Ctrl+Shift+4 przechwytuje zrzut ekranu do schowka, a następnie Ctrl+V wkleja go bezpośrednio do Claude Code. Można tego użyć do udostępniania makiet UI, komunikatów o błędach lub referencji projektowych.

Instalacja aplikacji GitHub do przeglądów PR

Po uruchomieniu /install-github-app Claude automatycznie przegląda PR-y. Jest to szczególnie wartościowe, gdy rozwój wspomagany przez AI zwiększa liczbę PR-ów — Claude często wychwytuje błędy logiczne i problemy bezpieczeństwa, które umykają ludzkim recenzentom.

Autonomiczna praca w kontenerach

Do w pełni autonomicznej pracy można uruchomić Claude Code w kontenerze Docker z tmux jako warstwą kontrolną. Lokalny Claude Code kontroluje instancję w kontenerze, która może wykonywać długotrwałe lub eksperymentalne zadania bez ręcznego zatwierdzania. Jeśli coś pójdzie nie tak, jest to odizolowane.

# Conceptual pattern (varies by setup)
# Local Claude Code → tmux → Container Claude Code
# Results pulled back when complete

Tryb Docker Sandbox (szybki start): Claude Code obsługuje uproszczony sandbox Docker poprzez podpolecenie docker. Tworzy to izolowane środowisko do eksploracji niezaufanych baz kodu lub bezpiecznego uruchamiania eksperymentalnych promptów.⁶³

# Run Claude Code in Docker sandbox
docker sandbox run claude

# Or with specific project
docker sandbox run claude /path/to/project

Trybu sandbox należy używać, gdy: - Eksploruje się nieznane lub niezaufane bazy kodu - Testuje się eksperymentalne prompty, które mogą modyfikować pliki - Uruchamia się autonomiczne sesje wymagające całkowitej izolacji - Uczy się Claude Code bez ryzyka dla rzeczywistych plików

Gemini CLI jako rozwiązanie zastępcze

Narzędzie WebFetch w Claude Code nie ma dostępu do niektórych stron (np. Reddit). Można utworzyć skill informujący Claude o użyciu Gemini CLI jako rozwiązania zastępczego — Gemini ma dostęp do sieci i może pobierać treści ze stron, do których Claude nie ma bezpośredniego dostępu.

Wzorzec fabryki meta-agentów

Zamiast tworzyć agentów wykonujących zadania, można utworzyć agenta tworzącego innych agentów. To nie jest sprytna rekurencja — to prawdziwy mnożnik produktywności dla złożonych przepływów automatyzacji.

Claude Squad: menedżer wielu agentów

Claude Squad zarządza wieloma instancjami Claude Code równolegle, każdą w osobnej sesji tmux z izolowanymi worktree. Można uruchamiać kilku agentów jednocześnie na różnych zadaniach, monitorować ich postęp z jednego pulpitu i pobierać wyniki po zakończeniu.⁶⁵

# Install
npm install -g @smtg-ai/claude-squad

# Start multiple agents
claude-squad start "Implement auth feature" --worktree auth-feature
claude-squad start "Write API tests" --worktree api-tests
claude-squad start "Update documentation" --worktree docs-update

# Monitor all agents
claude-squad status

Przypadki użycia: - Równoległe rozwijanie niezależnych funkcji przez agentów - Uruchamianie eksploracyjnych promptów bez blokowania głównej sesji - Skalowanie autonomicznego kodowania poza pojedyncze okno kontekstowe

Statystyki produktywności zaawansowanych użytkowników

Boris Cherny zademonstrował potencjał Claude Code: w ciągu 30 dni zrealizował 259 PR-ów z 497 commitami — 40 000 dodanych i 38 000 usuniętych linii. To pokazuje, co jest możliwe, gdy Claude Code jest w pełni zintegrowany z przepływem pracy deweloperskiej.

Osoby warte śledzenia

Aby być na bieżąco z rozwojem Claude Code, warto śledzić te konta:

Zespół Anthropic (źródła pierwotne)

Najlepsi twórcy treści

Kluczowe zasoby

• Wydania GitHub: anthropics/claude-code/releases - Śledź tylko wydania
• Discord: Kanały społeczności Anthropic
• Pełna lista: Zobacz ~/.claude/docs/following-list.md dla 20+ wyselekcjonowanych kont

Boris i zespół Anthropic dzielą się funkcjami w miarę ich wdrażania — często jest to najszybszy sposób na poznanie nowych możliwości, zanim dokumentacja nadąży.

Typowe antywzorce

Wiedza o tym, czego NIE robić, często dostarcza więcej wartości niż najlepsze praktyki. Te wzorce konsekwentnie powodują problemy:

Antywzorce kosztowe

Antywzorce kontekstowe

Antywzorce przepływu pracy

Antywzorce konfiguracyjne

Antywzorce promptów

Przepisy na przepływy pracy

Kompleksowe wzorce dla typowych scenariuszy.

Przepis 1: Rozpoczynanie nowego projektu

# 1. Initialize
cd my-project
claude

# 2. Let Claude understand the codebase
> "Explore this codebase and summarize the architecture"

# 3. Set up project configuration
> /init

# 4. Create CLAUDE.md with learned patterns
> "Create CLAUDE.md documenting the patterns you observed"

# 5. Add team commands
> "Create a /test command that runs our test suite"
> "Create a /deploy command for staging deployment"

Przepis 2: Codzienny przepływ pracy deweloperskiej

# 1. Continue yesterday's session
claude -c

# 2. Quick context recap
> "What did we work on yesterday?"

# 3. Check current state
> /status

# 4. Work on feature (Sonnet handles most tasks)
> "Implement the user profile endpoint"

# 5. Proactive context management
> /compact  # Before context exceeds 50%

# 6. Check spending
> /cost

# 7. End session cleanly
> "Summarize what we accomplished today"

Przepis 3: Złożona refaktoryzacja

# 1. Use Opus for planning, Sonnet for execution
> /model opusplan

# 2. Plan the refactoring
> "Plan refactoring our authentication from sessions to JWT"

# 3. Review the plan
# (Claude presents approach, you approve or modify)

# 4. Execute with Sonnet
> "Execute the plan"

# 5. Verify nothing broke
> "Have an explore agent verify all auth-related tests pass"

# 6. Review the diff
> !git diff

Przepis 4: Automatyzacja przeglądów PR

# In CI/CD (GitHub Actions, etc.)
claude -p "Review this PR for:" \
  --input-file pr_diff.txt \
  --output-format json \
  --permission-mode plan \
  --max-turns 5 << EOF
- Security vulnerabilities
- Performance issues
- Code style violations
- Missing test coverage
Provide findings in JSON format.
EOF

Przepis 5: Debugowanie problemów produkcyjnych

# 1. Configure Sentry MCP for error access
claude --add-mcp sentry

# 2. Get error context
> "Fetch the last 10 errors from Sentry for the auth service"

# 3. Deep dive with thinking
> Tab  # Enable extended thinking
> "Analyze these errors and identify the root cause"

# 4. Fix and verify
> "Implement a fix and add a regression test"
> !npm test

Przewodnik migracji

Przechodzisz z innych narzędzi AI do kodowania? Oto jak mapują się poszczególne koncepcje.

Z GitHub Copilot

Co zyskujesz: Prawdziwe możliwości agentowe—Claude Code czyta bazę kodu, uruchamia testy, tworzy PR-y i deleguje do subagentów. Nie tylko sugestie.

Z Cursor

Co zyskujesz: Integracje MCP (bazy danych, GitHub, Sentry), delegowanie do subagentów, hooks do automatyzacji i natywny workflow terminalowy.

Z ChatGPT / Claude Web

Co zyskujesz: Wszystko. Interfejsy webowe wymagają przepływów pracy opartych na kopiowaniu i wklejaniu; Claude Code operuje bezpośrednio na bazie kodu.

Kluczowe zmiany w podejściu

1. Przestań kopiować kod. Claude Code zapisuje bezpośrednio do plików.
2. Przestań przełączać kontekst. MCP wprowadza zewnętrzne narzędzia do sesji.
3. Deleguj agresywnie. Subagenty obsługują eksplorację bez zaśmiecania kontekstu.
4. Automatyzuj za pomocą hooks. Formatowanie, linting, logowanie dzieją się automatycznie.
5. Myśl sesjami. Kontynuuj pracę z -c, nie nowymi konwersacjami.

Kluczowe wnioski

Dla programistów: - Haiku kosztuje 10-20x mniej niż Opus—używaj do subagentów i prostych zadań - Używaj /compact proaktywnie podczas długich sesji, aby zarządzać kontekstem - Identyfikatory sesji kodujące kontekst (feature-${branch}-${timestamp}) pomagają nawigować do poprzedniej pracy - Poprzedzaj częste prompty znakiem #, aby dodać do trwałej pamięci bez dodatkowego pisania

Dla DevOps i zespołów platformowych: - Tryb headless (flaga -p) umożliwia integrację CI/CD z wyjściem JSON do parsowania - Hooks gwarantują wykonanie niezależnie od zachowania modelu—używaj do lintingu, formatowania, kontroli bezpieczeństwa - MCP rozszerza możliwości o bazy danych, GitHub, Sentry i ponad 300 integracji - Zadania w tle (prefiks &) działają na Claude Code Remote do asynchronicznego wykonywania

Dla zespołów bezpieczeństwa: - Reguły uprawnień są ewaluowane według zasady first-match-wins—strukturyzuj listy allow/deny ostrożnie - Tryb sandbox izoluje system plików i sieć dla niezaufanych baz kodu - Wzorce Bash dopasowują tylko prefiksy—Bash(curl:*) blokuje wszystkie curl, nie tylko konkretne URL-e - Zarządzane ustawienia enterprise nie mogą być nadpisane przez użytkowników

Dla liderów zespołów: - Skills aktywują się automatycznie na podstawie kontekstu—osadzaj wiedzę domenową bez jawnego wywoływania - Skills projektu są commitowane do git—współpracownicy automatycznie otrzymują ustandaryzowaną wiedzę - Śledzenie kosztów przez /cost pokazuje rozbicie sesji; planuj 10k-300k TPM na użytkownika w zależności od wielkości zespołu - Niestandardowe polecenia w .claude/commands/ tworzą wielokrotnego użytku przepływy pracy

Dla architektów enterprise: - Zarządzane ustawienia wdrażają polityki organizacyjne przez /etc/claude-code/managed-settings.json - AWS Bedrock, Google Vertex AI i Microsoft Foundry integrują się z istniejącym rozliczaniem chmurowym - Extended thinking (Tab do przełączania) poprawia złożone rozumowanie przy wyższym koszcie - Rozpocznij pilotaż z 5-10 programistami przed pełnym wdrożeniem

Karta szybkiego odniesienia

Wydrukuj to. Przyklej do monitora.

╔═══════════════════════════════════════════════════════════════╗
║                    CLAUDE CODE QUICK REFERENCE                 ║
╠═══════════════════════════════════════════════════════════════╣
║  MODELS                                                        ║
║    haiku     $1/$5/M     Exploration, simple tasks            ║
║    sonnet    $3/$15/M    Daily coding (default)               ║
║    opus      $5/$25/M    Architecture, hard problems          ║
║    sonnet[1m] $6/$22.50/M Large codebases (1M context)        ║
╠═══════════════════════════════════════════════════════════════╣
║  ESSENTIAL COMMANDS                                            ║
║    /compact        Reduce context (do at 50% capacity)        ║
║    /cost           Check session spending                     ║
║    /model opus     Switch to Opus                             ║
║    /status         Show current state                         ║
║    /init           Set up project config                      ║
║    /mcp            Configure integrations                     ║
╠═══════════════════════════════════════════════════════════════╣
║  KEYBOARD SHORTCUTS                                            ║
║    Tab             Toggle extended thinking                   ║
║    Shift+Tab       Cycle permission modes                     ║
║    Ctrl+C          Interrupt current operation                ║
║    Esc → Esc       Rewind last change                         ║
║    Ctrl+L          Clear screen                               ║
╠═══════════════════════════════════════════════════════════════╣
║  PREFIXES                                                      ║
║    #message        Add to persistent memory                   ║
║    @path/file      Reference file in prompt                   ║
║    !command        Execute bash directly                      ║
║    &task           Send to cloud (async)                      ║
╠═══════════════════════════════════════════════════════════════╣
║  CONFIG FILE HIERARCHY (first found wins)                      ║
║    .claude/settings.local.json    Personal (gitignored)       ║
║    .claude/settings.json          Project (shared)            ║
║    ~/.claude/settings.json        User global                 ║
║    /etc/.../managed-settings.json Enterprise (locked)         ║
║    CLAUDE.md                      Project context             ║
╠═══════════════════════════════════════════════════════════════╣
║  DAILY WORKFLOW                                                ║
║    1. claude -c              Continue session                 ║
║    2. Work on features       Use Sonnet                       ║
║    3. /compact               Before context bloats            ║
║    4. /cost                  Check spending                   ║
║    5. Summarize              Clean exit                       ║
╠═══════════════════════════════════════════════════════════════╣
║  DECISION RULES                                                ║
║    Simple task?        → Haiku                                ║
║    Hard reasoning?     → Opus                                 ║
║    Everything else?    → Sonnet                               ║
║    Must always run?    → Hook (not prompt)                    ║
║    Auto-apply wisdom?  → Skill (not command)                  ║
║    Needs isolation?    → Subagent                             ║
╚═══════════════════════════════════════════════════════════════╝

Historia zmian

Ten dokument referencyjny jest żywym dokumentem. Aktualizacje są wprowadzane wraz z rozwojem Claude Code.

Uruchom /update-cc-guide, aby przeskanować i zastosować najnowsze aktualizacje Claude Code.

Referencje