Konfiguracja i ustawienia Claude Code

Rozpoczęcie pracy z Claude Code wymaga przemyślanej konfiguracji, aby zmaksymalizować jego możliwości. Te 15 wskazówek pomoże ci skonfigurować Claude Code dla optymalnej wydajności — niezależnie od tego, czy pracujesz solo, czy jako część zespołu.

Instalacja i integracja z IDE

Wskazówka 1: Zainstaluj rozszerzenie VS Code

Rozszerzenie Claude Code działa z VS Code, Cursor i Windsurf. Choć jest to zasadniczo tylko launcher, zapewnia kluczowe korzyści:

• Szybkie uruchamianie z IDE za pomocą skrótów klawiszowych
• Wiele instancji w równoległych panelach dla różnych części bazy kodu
• Bezproblemowe referencje plików między twoim edytorem a Claude Code
• Zintegrowane przeglądanie różnic do recenzowania zmian

VS Code

# Zainstaluj z marketplace VS Code
code --install-extension anthropic.claude-code

Cursor

# Działa automatycznie z Cursor
# Rozszerzenie dostępne w marketplace Cursor

JetBrains

# Szukaj "Claude Code" w:
# Settings → Plugins → Marketplace

Wskazówka

Zaawansowani użytkownicy opisują ewolucję od używania Claude Code jako narzędzia w panelu bocznym do uczynienia go swoim głównym interfejsem — sprawdzają rzeczywisty kod tylko podczas recenzowania zmian.

Wskazówka 2: Użyj optymalnej metody instalacji

Natywny instalator to zalecany sposób instalacji Claude Code — aktualizuje się w tle, dzięki czemu automatycznie pozostajesz na najnowszej wersji:

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

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

Alternatywne metody instalacji:

Homebrew (macOS)

brew install --cask claude-code

Instalacje przez Homebrew nie aktualizują się automatycznie — okresowo uruchamiaj brew upgrade claude-code.

npm (opcja zaawansowana)

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

npm pozostaje wspierane i instaluje ten sam natywny plik binarny; od v2.1.198 wymaga Node.js 22+ podczas instalacji. Preferuj instalator natywny dla najprostszego updatera, unikaj sudo, a instalacje npm aktualizuj przez npm install -g @anthropic-ai/claude-code@latest.

Containers

# Uruchom Claude Code wewnątrz oficjalnego referencyjnego kontenera dev
# Zobacz: https://code.claude.com/docs/en/devcontainer

Nie istnieje samodzielny obraz Docker. Dla izolowanego, powtarzalnego środowiska użyj udokumentowanego devcontainera, który dobrze współpracuje z --dangerously-skip-permissions w przypadku automatyzacji w piaskownicy.

Wskazówka 3: Pomiń monity o uprawnienia dla efektywności

Jedną z najbardziej wpływowych zmian konfiguracyjnych jest ominięcie ciągłych próśb o uprawnienia:

claude --dangerously-skip-permissions

To eliminuje przerwania dla:

• Uprawnień do edycji plików
• Podstawowego wykonywania komend
• Operacji Git
• Komend menedżera pakietów

Uwaga dotycząca bezpieczeństwa

Jest to podobne do trybu „yolo” w Cursor i naprawdę może uruchamiać destrukcyjne komendy bez pytania. Używaj go tylko w zaufanym kontekście w piaskownicy — devcontainerze, jednorazowej maszynie wirtualnej lub CI na gałęzi. Nigdy nie włączaj go na niezaufanym kodzie, współdzielonej maszynie ani gdziekolwiek, gdzie błędne rm/git push --force zrobiłoby szkodę. Dla złotego środka połącz --permission-mode plan z --allow-dangerously-skip-permissions, aby omijanie było dostępne, ale nieaktywne domyślnie.

Wskazówka 4: Zainstaluj GitHub CLI dla rozszerzonej integracji

GitHub CLI (gh) umożliwia potężne integracje Claude Code:

# macOS
brew install gh

# Linux/WSL
curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo gpg --dearmor -o /usr/share/keyrings/githubcli-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
sudo apt update && sudo apt install gh

# Windows
winget install GitHub.cli

Po instalacji uwierzytelnij się:

gh auth login

To umożliwia:

• Automatyczne tworzenie i recenzowanie PR
• Zarządzanie zgłoszeniami z Claude Code
• Operacje na repozytoriach
• Integrację z GitHub Actions

Wskazówka 5: Skonfiguruj poprawnie integrację z IDE

Skonfiguruj odpowiednią integrację z IDE dla płynnego przepływu pracy:

1. Skonfiguruj skróty klawiszowe

   // VS Code settings.json
   {
     "keybindings": [
       {
         "key": "cmd+shift+c",
         "command": "claude-code.open",
         "when": "editorTextFocus"
       }
     ]
   }

2. Ustaw powiązania plików

   {
     "files.associations": {
       "CLAUDE.md": "markdown",
       "*.claude": "markdown"
     }
   }

3. Skonfiguruj integrację terminala

   # Dodaj do ~/.zshrc lub ~/.bashrc
   alias cc="claude"
   alias ccc="claude --dangerously-skip-permissions"

Konfiguracja terminala i środowiska

Wskazówka 6: Skonfiguruj terminal dla optymalnego doświadczenia

Uruchom komendę konfiguracji terminala, aby ustawić odpowiednie powiązania klawiszy:

claude
# Następnie uruchom:
/terminal-setup

To umożliwia:

• Shift+Enter dla nowych linii w promptach
• Uzupełnianie Tab dla komend
• Nawigację po historii klawiszami strzałek
• Odpowiednie sekwencje escape do zatrzymywania operacji

Notatka

Jeśli masz problemy ze specjalnymi klawiszami, skonfiguruj terminal ręcznie:

# Dla iTerm2/Terminal.app
stty sane
export TERM=xterm-256color

Wskazówka 7: Używaj trybu planowania i opusplan dla dużych projektów

Przy refaktoryzacji na dużą skalę i pracy architektonicznej opieraj się na realnych mechanizmach planowania Claude Code, zamiast od razu rzucać się na edycję:

• Tryb planowania — Naciśnij Shift+Tab, aby przejść w tryb planowania (lub uruchom z claude --permission-mode plan). Claude bada i proponuje plan, nie dotykając plików, dopóki go nie zatwierdzisz.
• Alias modelu opusplan — Ustaw --model opusplan, aby Opus wykonywał rozumowanie w trybie planowania, a wykonanie spadało do Sonnet dla oszczędności kosztów. Zobacz Wskazówkę 8.
• Subagenci — Deleguj duże, zrównoleglone badania (np. „zmapuj każde miejsce wywołania tego API”) do subagentów, aby główny kontekst pozostał szczupły.
• --add-dir — Wprowadź sąsiednie repozytoria do zakresu dla refaktoryzacji między repozytoriami. Zobacz Wskazówkę 9.

Kiedy sięgnąć po tryb planowania

• Refaktoryzacja całych modułów lub podsystemów
• Analiza złożonych grafów zależności
• Praca z nieznanymi, starszymi bazami kodu
• Implementacja wzorców architektonicznych w wielu plikach

Wskazówka 8: Skonfiguruj preferencje modeli

Zrozum strategię wyboru modelu dla optymalnych rezultatów:

.claude/settings.json

{
  "model": "opusplan"
}

Pole model przyjmuje pojedynczy alias (default, best, fable, opus, sonnet, haiku, opusplan lub obsługiwany wariant [1m]) albo pełne ID modelu. Nie ma mapy modelPreferences per zadanie — zamiast tego wybierasz tutaj wartość domyślną i przełączasz się w locie za pomocą /model <alias> w trakcie sesji albo nadpisujesz przy starcie za pomocą claude --model <alias>.

Wytyczne wyboru modelu:

• Fable 5 (fable lub best, gdy jest dostępny): Najwyższy poziom możliwości — złożone refaktoryzacje wielu plików, budowanie od zera i długotrwałe zadania, gdzie jakość jest ważniejsza od kosztu. Nigdy nie jest automatycznym defaultem konta, po 7 lipca 2026 wymaga usage credits w kwalifikujących się planach subskrypcyjnych i nie jest dostępny przy zero data retention. Szczegóły znajdziesz w porównaniu modeli.
• Opus 4.8 (opus): Złożona architektura, projektowanie systemów i trudne debugowanie. Od v2.1.207 jest defaultem w Max, Team Premium, Enterprise pay-as-you-go, Anthropic API, Amazon Bedrock, Google Cloud Agent Platform i Claude Platform on AWS. Microsoft Foundry pozostaje na Sonnet 4.5, jeśli go nie nadpiszesz.
• Sonnet 5 (sonnet): Rutynowy rozwój, standardowe funkcje i refaktoryzacja. Jego natywny kontekst 1M nie wymaga sufiksu [1m] w Anthropic API. Jest defaultem konta w Pro, Team Standard i subskrypcyjnych miejscach Enterprise.
• Haiku 4.5 (haiku): Proste zadania, formatowanie, podstawowa generacja kodu
• opusplan: To, co najlepsze z obu — Opus w trybie planowania, Sonnet podczas wykonania; dla maksymalnej jakości użyj fable podczas planowania i Opus lub Sonnet do implementacji

Alias default może też rozwiązać się do modelu domyślnego organizacji. Dostawcy zewnętrzni mogą mapować aliasy rodzin na starsze modele, jeśli nie przypniesz ich pełnych ID specyficznych dla dostawcy.

Wskazówka 9: Skonfiguruj wiele katalogów roboczych

Dla projektów obejmujących wiele repozytoriów:

# Uruchom Claude Code z wieloma katalogami
claude --add-dir ../backend --add-dir ../frontend --add-dir ../shared

# Lub dodaj podczas sesji
/add-dir ../backend
/add-dir ../frontend

Dodatkowe katalogi mają zakres sesji: przekaż --add-dir przy uruchomieniu lub użyj komendy /add-dir w trakcie sesji. Aby dodatkowe katalogi pozostały między sesjami, ustaw permissions.additionalDirectories w .claude/settings.json — utrwala to ten sam dostęp bez ponownego wpisywania flag:

.claude/settings.json

{
  "permissions": {
    "additionalDirectories": ["../docs/"]
  }
}

Jeśli wolisz nie commitować tego do ustawień projektu, opakowanie komendy uruchamiającej w alias powłoki (zobacz Wskazówkę 5) wciąż jest dobrym, szybkim obejściem.

Konfiguracja projektu

Wskazówka 10: Optymalizuj środowisko shell

Upewnij się, że Claude Code dziedziczy twoje środowisko deweloperskie:

~/.claude/shell-init.sh

export PATH="$HOME/.local/bin:$PATH"
export NODE_OPTIONS="--max-old-space-size=8192"
source ~/.nvm/nvm.sh

# Niestandardowe aliasy, które Claude powinien znać
alias build="npm run build:all"
alias test="npm run test:coverage"
alias deploy="./scripts/deploy.sh"

Dokumentuj niestandardowe narzędzia w CLAUDE.md:

# Custom Tools and Commands

- `build`: Runs full build pipeline with type checking
- `test`: Runs tests with coverage reporting
- `deploy`: Deploys to staging (requires VPN connection)

Wskazówka 11: Skonfiguruj odpowiednie uprawnienia plików

Skonfiguruj swój projekt z odpowiednimi uprawnieniami:

# Napraw częste problemy z uprawnieniami
find . -type f -name "*.sh" -exec chmod +x {} \;
chmod -R u+rw .claude/

# Stwórz katalog .claude z odpowiednimi uprawnieniami
mkdir -p .claude/{commands,hooks,settings}
chmod 755 .claude

Wskazówka 12: Zainstaluj serwery MCP dla rozszerzonej funkcjonalności

Serwery Model Context Protocol (MCP) rozszerzają możliwości Claude Code:

// .mcp.json (poziom projektu)
{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp"]
    }
  }
}

Uwaga

Klucz najwyższego poziomu to mcpServers, a nie servers — Claude Code po cichu ignoruje błędnie nazwaną konfigurację. Serwer MCP git działa wyłącznie w Pythonie, więc używa uvx, a nie npx. Oficjalny GitHub MCP to teraz zdalny punkt końcowy HTTP powyżej (uwierzytelnij się raz za pomocą /mcp); stare paczki npm @modelcontextprotocol/server-github oraz server-postgres to zarchiwizowane serwery referencyjne — preferuj zdalny serwer GitHub i aktualny społecznościowy serwer Postgres.

Niezbędne serwery MCP do rozwoju:

• GitHub (zdalny https://api.githubcopilot.com/mcp/): PR-y, zgłoszenia, przegląd kodu
• git (uvx mcp-server-git): lokalne operacje git
• filesystem (@modelcontextprotocol/server-filesystem): operacje na plikach o ograniczonym zakresie
• Playwright (@playwright/mcp): automatyzacja przeglądarki i testy end-to-end
• Postgres: bezpośredni dostęp do bazy danych przez aktualny serwer społecznościowy (referencyjna paczka server-postgres jest zarchiwizowana)

Wskazówka 13: Użyj trybu debugowania do rozwiązywania problemów z MCP

Gdy serwery MCP nie działają poprawnie:

claude --debug "mcp"

To zapewnia:

• Szczegółowe logi połączeń
• Komunikaty błędów z serwerów MCP
• Walidację konfiguracji
• Metryki wydajności

Częste kroki rozwiązywania problemów:

1. Wypisz skonfigurowane serwery i ich status

   claude mcp list
   claude mcp get github

2. Potwierdź, że launchery są w twoim PATH

   which npx   # dla serwerów opartych na npm
   which uvx   # dla serwerów opartych na Pythonie, jak mcp-server-git

3. Przeanalizuj szczegółowo logi połączeń

   claude --debug "mcp"

Wskazówka 14: Skonfiguruj ustawienia specyficzne dla projektu

Stwórz kompleksową konfigurację projektu:

.claude/settings.json

{
  "permissions": {
    "allow": [
      "Read",
      "Edit",
      "Write",
      "Bash(git:*)",
      "Bash(npm:*)",
      "Bash(yarn:*)",
      "Bash(pnpm:*)",
      "mcp__git__*",
      "mcp__github__*"
    ]
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs -r prettier --write"
          }
        ]
      }
    ]
  }
}

Uwaga

Trzy szczegóły, które ludzie tu mylą. hooks to obiekt z kluczami będącymi nazwami zdarzeń (PostToolUse, SessionStart itd.), a nie płaska tablica. Komendy hooków otrzymują wywołanie narzędzia jako JSON na stdin — odczytaj edytowaną ścieżkę za pomocą jq -r '.tool_input.file_path'; nie ma zmiennej $CLAUDE_FILE_PATHS. I nie ma bloku security (allowNetworkAccess/allowedHosts/sensitiveFiles to nie są prawdziwe klucze) — ogranicz dostęp poprzez system uprawnień i piaskownicę.

Udostępnij zespołowi poprzez commitowanie do kontroli wersji:

git add .claude/settings.json
git commit -m "Add Claude Code project configuration"

Wskazówka 15: Skonfiguruj dozwolone narzędzia strategicznie

Równoważ bezpieczeństwo z produktywnością, dostosowując uprawnienia narzędzi:

Rozwój

{
  "permissions": {
    "allow": [
      "Read",
      "Edit",
      "Write",
      "Glob",
      "Grep",
      "Bash(*)",
      "mcp__github__*"
    ]
  }
}

Staging

{
  "permissions": {
    "allow": [
      "Read",
      "Edit",
      "Write",
      "Bash(git:*)",
      "Bash(npm:test)",
      "mcp__github__*"
    ]
  }
}

Produkcja

{
  "permissions": {
    "allow": [
      "Read",
      "Bash(git:log)",
      "Bash(git:status)"
    ]
  }
}

Użyj komendy /permissions do modyfikacji podczas sesji:

/permissions
# Wybierz narzędzia do zezwolenia/odmowy interaktywnie

Gotowe prompty do skopiowania

Oto prompty, które zamieniają świeży checkout w dobrze skonfigurowany projekt. Uruchom je wewnątrz Claude Code z katalogu głównego repozytorium.

Wskazówka

Wygeneruj projektowy CLAUDE.md na podstawie rzeczywistej bazy kodu:

Read package.json, the lockfile, and the top-level directory structure, then
write a concise CLAUDE.md for this repo. Cover: tech stack and versions, how to
run dev/build/test, the directory layout in two sentences, our naming and import
conventions (infer from existing code), and any gotchas you notice. Keep it
under 60 lines. Do not invent commands — only include scripts that exist.

Wskazówka

Wygeneruj zestaw uprawnień o zakresie projektu dla .claude/settings.json:

Look at how this project is built, tested, and deployed, then propose a
"permissions.allow" array for .claude/settings.json that lets you do day-to-day work
without prompts but keeps me in the loop for anything destructive. Use only real
tool names (Read, Edit, Write, Bash, Glob, Grep) and scoped Bash patterns like
Bash(npm:*). Explain each entry in one line. Do NOT include a catch-all Bash(*).

Wskazówka

Zbadaj, których serwerów MCP to repozytorium naprawdę potrzebuje:

Based on this project's stack and external dependencies (database, git host,
browser testing, etc.), tell me which MCP servers would meaningfully help and
which would just add token overhead. For each recommendation give the exact
.mcp.json entry (correct transport, real package name, uvx for Python servers),
and flag any I'm currently configured with that I don't need.

Gdy to zawodzi

Konfiguracja rzadko zawodzi głośno — zawodzi przez bycie po cichu ignorowaną. Oto zwykli winowajcy i szybkie naprawy.

• Serwer MCP nie chce się połączyć. Uruchom claude --debug "mcp", aby zobaczyć rzeczywisty błąd, a następnie potwierdź, że launcher jest zainstalowany (which npx, which uvx). Serwery działające wyłącznie w Pythonie, jak mcp-server-git, potrzebują uvx w PATH — npx dla nich nie zadziała.
• .claude/settings.json wydaje się ignorowany. Sprawdź zakres i ścieżkę: ustawienia projektu znajdują się w .claude/settings.json w katalogu głównym repozytorium; ustawienia użytkownika w ~/.claude/settings.json. Literówka w kluczu (na przykład servers zamiast mcpServers w .mcp.json albo hooks jako tablica zamiast obiektu) sprawia, że Claude Code pomija ten blok całkowicie, bez żadnego błędu.
• Monity o uprawnienia wciąż się pojawiają. Twoja reguła permissions.allow prawdopodobnie nie pasuje. Nazwy narzędzi rozróżniają wielkość liter (Read, nie View), a zakres Bash używa formy Bash(cmd:*). Użyj /permissions w trakcie sesji, aby dodać dokładną regułę, a następnie skopiuj ją do ustawień.
• Rozszerzenie nie chce się uruchomić. Przeładuj okno IDE (Paleta komend: „Developer: Reload Window”) albo zainstaluj ponownie bezpośrednio z VS Code Marketplace.

Uwaga

Powstrzymaj się od zaczynania z szeroko otwartymi uprawnieniami „tylko po to, by ruszyć”. Pobłażliwy .claude/settings.json zacommitowany do repozytorium dotyczy każdego członka zespołu i każdego przebiegu CI. Zacznij ciasno (zakładka Staging powyżej), a potem poszerzaj konkretne reguły w miarę pojawiania się rzeczywistych tarć.

Następne kroki

Po właściwym skonfigurowaniu Claude Code jesteś gotowy, by zoptymalizować kontekst swojego projektu. Przejdź do Optymalizacja CLAUDE.md, aby nauczyć się, jak tworzyć skuteczną trwałą pamięć dla swoich projektów.