Optymalizacja wydajności

Wydajność w Claude Code to nie tylko szybkość – to maksymalizowanie wartości z każdego tokena, minimalizowanie zanieczyszczenia kontekstu i orkiestracja przepływów pracy, które skalują się efektywnie. Ten przewodnik ujawnia strategie optymalizacji, które przekształcają Claude z pomocnego ale kosztownego asystenta w opłacalną potęgę rozwoju.

Zrozumienie ekonomii tokenów

Prawdziwy koszt rozwoju AI

Każda interakcja z Claude Code zużywa tokeny – podstawową jednostkę obliczeń AI. Zrozumienie ekonomii tokenów jest kluczowe dla zrównoważonego rozwoju wspomaganego przez AI:

Tokeny wejściowe

Każdy plik, prompt i kontekst zużywa tokeny wejściowe. Z Claude Sonnet 4 po $3 za milion tokenów wejściowych, jeden duży skan bazy kodu może kosztować dolary.

Tokeny wyjściowe

Każda odpowiedź, edycja i generowanie kosztuje tokeny wyjściowe po $15 za milion. Gadatliwe wyjaśnienia i generowanie dużych plików szybko się sumuje.

Okno kontekstu

Limit 200K tokenów oznacza strategiczne zarządzanie kontekstem. Nie możesz po prostu rzucić wszystkiego na Claude – musisz być selektywny.

Korzyści cache'owania

90% zniżka na treści z cache zmienia ekonomię. Strategiczne cache’owanie może zmniejszyć koszty o rząd wielkości.

Strategie optymalizacji kontekstu

Sztuka selektywnego kontekstu

Wzorzec 1: Progresywne ładowanie kontekstu

Zacznij minimalnie, rozszerzaj w razie potrzeby:

# ŹLE: Podejście kuchenne zlewu
claude "refaktoryzuj całe uwierzytelnianie" auth/ middleware/ utils/ tests/

# DOBRZE: Progresywne rozszerzanie
claude "przeanalizuj wzorce auth" auth/core.ts
# Następnie: "teraz sprawdź integrację middleware" middleware/auth.ts
# Następnie: "zaktualizuj powiązane testy" tests/auth/

Wzorzec 2: Strategiczne wykluczanie plików

Używaj wzorców .claudeignore efektywnie:

# .claudeignore - Wyklucz szum, zachowaj sygnał
node_modules/
dist/
build/
coverage/
*.test.js     # Dołączaj testy tylko gdy potrzeba
*.spec.ts     # Podobnie dla speców
*.min.js      # Nigdy nie dołączaj zminifikowanych plików
*.map         # Source mapy marnują tokeny
package-lock.json
yarn.lock
pnpm-lock.yaml

# Duże wygenerowane pliki
*.generated.ts
*.pb.go
*_gen.go

# Dokumentacja (dołączaj tylko gdy istotna)
docs/**/*.md
README.md     # Zachowaj główne README

Wzorzec 3: Recykling kontekstu

Używaj ponownie kosztowny kontekst w wielu operacjach:

# Załaduj kontekst raz, używaj wielokrotnie
claude-code --repl "przeanalizuj architekturę serwisu użytkowników" services/user/

# W trybie REPL:
> "zidentyfikuj wąskie gardła wydajności"
> "zasugeruj strategie cache'owania"
> "wygeneruj plan optymalizacji"
> "zaimplementuj top 3 optymalizacje"

Techniki optymalizacji promptów

Pisanie tokenowo-efektywnych promptów

Bądź konkretny

Niejasne prompty prowadzą do gadatliwych odpowiedzi. Konkretne prompty dają konkretne odpowiedzi.

Pomijaj wyjaśnienia

Gdy wiesz czego chcesz, pomiń tutorial: “zaimplementuj X (nie potrzeba wyjaśnień)”

Używaj szablonów

Szablony promptów wielokrotnego użytku redukują tokeny wejściowe i poprawiają spójność.

Żądaj formatów

“Odpowiedz tylko kodem” lub “Tylko odpowiedź JSON” znacznie redukuje tokeny wyjściowe.

Efektywne wzorce promptów

# NIEEFEKTYWNE: Gadatliwe żądanie
"Czy mógłbyś proszę pomóc mi zrefaktoryzować ten middleware
uwierzytelniania aby używał nowej biblioteki JWT? Chciałbym
zrozumieć zmiany i upewnić się że jest kompatybilny wstecz..."

# EFEKTYWNE: Bezpośrednie i konkretne
"Refaktoryzuj middleware auth: stara-jwt → nowa biblioteka jwt.
Zachowaj kompatybilność API. Tylko kod."

# NIEEFEKTYWNE: Opowiadanie historii
"Mam ten dziwny błąd gdy użytkownicy logują się na
urządzeniach mobilnych. Czasami działa, czasami nie.
Błąd mówi coś o tokenach..."

# EFEKTYWNE: Strukturalny raport
"Błąd: Sporadyczne niepowodzenie auth na mobile
Błąd: 'Invalid token format'
Kontekst: Walidacja JWT w mobile-auth.ts:42
Wymagana poprawka. Pokaż tylko poprawioną funkcję."

# NIEEFEKTYWNE: Otwarte pytanie
"Zaimplementuj system cache'owania dla naszego API"

# EFEKTYWNE: Konkretne wymagania
"Zaimplementuj cache'owanie Redis:
- getThing() → sprawdź cache → miss? pobierz & przechowaj
- 5min TTL, eksmisja LRU
- TypeScript, obsługa błędów dołączona
Tylko kod, bez wyjaśnień"

Strategie cache’owania dla redukcji kosztów

Wykorzystywanie 90% zniżki

Cache’owanie Claude Code może dramatycznie zredukować koszty gdy używane strategicznie:

Wzorzec 1: Stabilne cache’owanie kontekstu

Utrzymuj często używany kontekst w cache:

# Pierwszy run: Pełny koszt
claude "przeanalizuj strukturę bazy kodu" --include-types --include-interfaces

# Kolejne runy: 90% taniej jeśli kontekst nie zmieniony
claude "zaimplementuj nowe funkcje użytkowników"  # Używa ponownie cache'owanej analizy typów

Wzorzec 2: Operacje wieloprzebiegowe

Strukturyzuj operacje aby zmaksymalizować trafienia cache:

Początkowy przebieg analizy

claude "przeanalizuj wszystkie serwisy, zidentyfikuj wzorce" services/

Przebiegi implementacji (używając cache’owanej analizy)

claude "dodaj logowanie do serwisu użytkowników na podstawie wzorców"
claude "dodaj logowanie do serwisu zamówień na podstawie wzorców"
claude "dodaj logowanie do serwisu płatności na podstawie wzorców"

Przebieg weryfikacji (wciąż używając cache)

claude "zweryfikuj spójność logowania we wszystkich serwisach"

Wzorzec 3: Rozwój oparty na szablonach

Utwórz szablony z cache dla częstych operacji:

# Cache'uj kontekst szablonu
claude "przeanalizuj nasze wzorce API" templates/api-template.ts

# Używaj ponownie dla wielu endpointów (90% taniej każdy)
claude "utwórz endpoint użytkowników zgodnie z szablonem"
claude "utwórz endpoint zamówień zgodnie z szablonem"
claude "utwórz endpoint płatności zgodnie z szablonem"

Wzorce optymalizacji przepływu pracy

Grupowanie dla efektywności

Wzorzec 1: Wsadowe aktualizacje wielu plików

# NIEEFEKTYWNE: Wiele oddzielnych operacji
claude "zaktualizuj model użytkownika" models/user.ts
claude "zaktualizuj serwis użytkownika" services/user.ts
claude "zaktualizuj kontroler użytkownika" controllers/user.ts
claude "zaktualizuj testy użytkownika" tests/user.test.ts

# EFEKTYWNE: Jedna skoordynowana operacja
claude "dodaj weryfikację email do systemu użytkowników" \
  models/user.ts \
  services/user.ts \
  controllers/user.ts \
  tests/user.test.ts \
  --plan "1. Dodaj pole emailVerified 2. Dodaj serwis weryfikacji 3. Dodaj endpointy 4. Zaktualizuj testy"

Wzorzec 2: Inteligentne okienkowanie kontekstu

Zarządzaj oknem kontekstu strategicznie:

// Niestandardowy skrypt zarządzania kontekstem
const contextManager = {
  maxTokens: 150000,  // Zostaw bufor
  currentTokens: 0,

  addFile(path: string, priority: number) {
    const tokens = estimateTokens(readFile(path));
    if (this.currentTokens + tokens > this.maxTokens) {
      this.evictLowPriority();
    }
    this.files.push({ path, tokens, priority });
    this.currentTokens += tokens;
  },

  evictLowPriority() {
    // Usuń pliki o najniższym priorytecie aż będzie miejsce
    this.files.sort((a, b) => b.priority - a.priority);
    while (this.currentTokens > this.maxTokens * 0.8) {
      const removed = this.files.pop();
      this.currentTokens -= removed.tokens;
    }
  }
};

Monitorowanie wydajności

Śledzenie użycia tokenów

Utwórz system śledzenia tokenów:

#!/bin/bash
# Owij claude-code aby śledzić użycie
claude_tracked() {
  local start_time=$(date +%s)
  local temp_log=$(mktemp)

  # Uruchom z logowaniem
  claude "$@" 2>&1 | tee "$temp_log"

  # Wyciągnij użycie tokenów (założenie że claude-code wypisuje użycie)
  local input_tokens=$(grep "Input tokens:" "$temp_log" | awk '{print $3}')
  local output_tokens=$(grep "Output tokens:" "$temp_log" | awk '{print $3}')
  local cached_tokens=$(grep "Cached tokens:" "$temp_log" | awk '{print $3}')

  # Oblicz koszty
  local input_cost=$(echo "$input_tokens * 0.003 / 1000" | bc -l)
  local output_cost=$(echo "$output_tokens * 0.015 / 1000" | bc -l)
  local cached_cost=$(echo "$cached_tokens * 0.0003 / 1000" | bc -l)
  local total_cost=$(echo "$input_cost + $output_cost + $cached_cost" | bc -l)

  # Loguj do pliku śledzenia
  echo "$(date +%Y-%m-%d\ %H:%M:%S),\"$*\",$input_tokens,$output_tokens,$cached_tokens,$total_cost" >> ~/.claude-usage.csv

  # Sprzątanie
  rm "$temp_log"
}

alias claude-code="claude_tracked"

Dashboard analityki użycia

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

def analyze_usage():
    df = pd.read_csv('~/.claude-usage.csv', names=[
        'timestamp', 'command', 'input_tokens',
        'output_tokens', 'cached_tokens', 'cost'
    ])

    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df['date'] = df['timestamp'].dt.date

    # Trend codziennych kosztów
    daily_cost = df.groupby('date')['cost'].sum()

    # Efektywność tokenów (cache vs świeże)
    token_efficiency = df.groupby('date').agg({
        'input_tokens': 'sum',
        'cached_tokens': 'sum'
    })
    token_efficiency['cache_rate'] = (
        token_efficiency['cached_tokens'] /
        (token_efficiency['input_tokens'] + token_efficiency['cached_tokens'])
    )

    # Najdroższe operacje
    expensive_ops = df.nlargest(10, 'cost')[['timestamp', 'command', 'cost']]

    return daily_cost, token_efficiency, expensive_ops

Zaawansowane techniki optymalizacji

Niestandardowy wybór modelu

Używaj właściwego modelu do zadania:

# Złożona refaktoryzacja: Używaj Sonnet
CLAUDE_MODEL=claude-4-sonnet claude "refaktoryzuj system uwierzytelniania"

# Proste poprawki: Mógłby używać Haiku (gdy dostępny w CLI)
CLAUDE_MODEL=claude-haiku claude "napraw literówkę w README"

# Przegląd kodu: Opus dla najgłębszej analizy
CLAUDE_MODEL=claude-4.1-opus claude "audyt bezpieczeństwa systemu auth"

Przetwarzanie przyrostowe

Dziel duże zadania na kawałki efektywne tokenowo:

// Skrypt migracji przyrostowej
async function migrateCodebase() {
  const files = await glob('src/**/*.js');
  const batchSize = 10; // Plików na partię

  for (let i = 0; i < files.length; i += batchSize) {
    const batch = files.slice(i, i + batchSize);

    // Przetwarzaj partię z skoncentrowanym kontekstem
    await claudeCode([
      'zmigruj na TypeScript',
      ...batch,
      '--context-limit', '50000',  // Mniejszy kontekst na partię
      '--cache-strategy', 'aggressive'
    ]);

    // Wyczyść cache między partiami jeśli potrzeba
    if (i % 50 === 0) {
      await claudeCode(['--clear-cache']);
    }
  }
}

Przykłady optymalizacji z rzeczywistego świata

Studium przypadku: Duży projekt refaktoryzacji

“Zredukowaliśmy zadanie refaktoryzacji 2 milionów tokenów do 400K tokenów (80% redukcja) używając tych technik:”

Faza pre-analizy
- Uruchomiono analizę statyczną aby zidentyfikować rzeczywiste zależności
- Utworzono graf zależności aby zoptymalizować dołączanie kontekstu
- Koszt: 50K tokenów
Refaktoryzacja dzielona
- Podzielono na 20 niezależnych kawałków na podstawie analizy zależności
- Każdy kawałek używał tylko odpowiedniego kontekstu
- Koszt: 300K tokenów (vs 1.5M z pełnym kontekstem)
Przebieg weryfikacji
- Jeden przebieg z cache’owanymi wzorcami refaktoryzacji
- Zweryfikowano spójność we wszystkich zmianach
- Koszt: 50K tokenów (90% z cache)

Studium przypadku: Codzienny przepływ pracy rozwoju

Zoptymalizowany codzienny przepływ pracy redukujący koszty o 75%:

Przed
Po

# Przygotowanie porannego standupu: 100K tokenów
claude "podsumuj wszystkie wczorajsze zmiany" .

# Rozwój funkcji: 500K tokenów
claude "zaimplementuj dashboard użytkownika" src/

# Naprawy błędów: 300K tokenów
claude "napraw wszystkie błędy lintingu" .

# Łącznie: 900K tokenów/dzień ($3.60)

# Przygotowanie porannego standupu: 20K tokenów
claude "podsumuj zmiany" --since yesterday --format brief

# Rozwój funkcji: 150K tokenów
claude "zaimplementuj dashboard użytkownika" \
  src/components/Dashboard.tsx \
  src/api/dashboard.ts \
  --reuse-context

# Naprawy błędów: 50K tokenów
claude "napraw tylko krytyczne linty" --severity error

# Łącznie: 220K tokenów/dzień ($0.88)

Lista kontrolna najlepszych praktyk wydajności

Codzienna lista kontrolna optymalizacji

Podsumowanie

Optymalizacja wydajności w Claude Code polega na pracy mądrzej, nie ciężej. Rozumiejąc ekonomię tokenów, wykorzystując cache’owanie i strukturyzując przepływy pracy efektywnie, możesz zredukować koszty o 80% lub więcej jednocześnie faktycznie poprawiając szybkość rozwoju. Kluczem jest traktowanie tokenów jako cennego zasobu i optymalizowanie ich użycia tak jak optymalizowałbyś wydajność kodu.