Optymalizacja wydajności

Wydajność w Claude Code to nie tylko szybkość – to maksymalizacja wartości każdego tokena, minimalizacja 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 drogiego asystenta w opłacalną potęgę rozwoju.

Zrozumienie ekonomii tokenów

Rzeczywisty 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. Przy Claude Sonnet 4.5 po 3 USD za milion tokenów wejściowych, pojedyncze skanowanie dużej bazy kodu może kosztować dolary.

Tokeny wyjściowe

Każda odpowiedź, edycja i generowanie kosztuje tokeny wyjściowe po 15 USD za milion. Rozwlekłe wyjaśnienia i generowanie dużych plików szybko się sumują.

Okno kontekstu

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

Korzyści z cache'owania

90% zniżki na treści z cache’a przekształca 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 miarę potrzeb:

# ŹLE: Podejście kuchenne zlewu
claude "refactor all authentication" auth/ middleware/ utils/ tests/

# DOBRZE: Progresywne rozszerzanie
claude "analyze auth patterns" auth/core.ts
# Następnie: "now check middleware integration" middleware/auth.ts
# Następnie: "update related tests" tests/auth/

Wzorzec 2: Strategiczne wykluczanie plików

Efektywnie używaj wzorców .claudeignore:

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

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

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

Wzorzec 3: Recykling kontekstu

Używaj ponownie kosztownego kontekstu w wielu operacjach:

# Załaduj kontekst raz, użyj wielokrotnie
claude-code --repl "analyze user service architecture" services/user/

# W trybie REPL:
> "identify performance bottlenecks"
> "suggest caching strategies"
> "generate optimization plan"
> "implement top 3 optimizations"

Techniki optymalizacji promptów

Pisanie promptów efektywnych tokenowo

Bądź konkretny

Niejasne prompty prowadzą do rozwlekłych odpowiedzi. Konkretne prompty dają konkretne odpowiedzi.

Pomiń wyjaśnienia

Gdy wiesz, czego chcesz, pomiń tutorial: “implement X (no explanation needed)”

Używaj szablonów

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

Żądaj formatów

“Reply with code only” lub “JSON response only” znacząco zmniejsza tokeny wyjściowe.

Efektywne wzorce promptów

# NIEEFEKTYWNE: Rozwlekłe żądanie
"Could you please help me refactor this authentication
middleware to use the new JWT library? I'd like to
understand the changes and make sure it's backwards
compatible..."

# EFEKTYWNE: Bezpośrednie i konkretne
"Refactor auth middleware: old-jwt → new-jwt library.
Maintain API compatibility. Code only."

# NIEEFEKTYWNE: Opowiadanie historii
"I'm getting this weird error when users log in on
mobile devices. Sometimes it works, sometimes not.
The error says something about tokens..."

# EFEKTYWNE: Ustrukturyzowany raport
"Bug: Intermittent auth failure on mobile
Error: 'Invalid token format'
Context: JWT validation in mobile-auth.ts:42
Fix required. Show only the corrected function."

# NIEEFEKTYWNE: Otwarte
"Implement a caching system for our API"

# EFEKTYWNE: Konkretne wymagania
"Implement Redis caching:
- getThing() → check cache → miss? fetch & store
- 5min TTL, LRU eviction
- TypeScript, error handling included
Code only, no explanation"

Strategie cache’owania dla redukcji kosztów

Wykorzystanie 90% zniżki

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

Wzorzec 1: Cache’owanie stabilnego kontekstu

Utrzymuj często używany kontekst w cache:

# Pierwsze uruchomienie: Pełny koszt
claude "analyze codebase structure" --include-types --include-interfaces

# Kolejne uruchomienia: 90% taniej jeśli kontekst się nie zmienił
claude "implement new user features"  # Używa ponownie cache'owanej analizy typów

Wzorzec 2: Operacje wieloprzebiegowe

Strukturyzuj operacje, aby maksymalizować trafienia cache:

Początkowy przebieg analizy

claude "analyze all services, identify patterns" services/

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

claude "add logging to user service based on patterns"
claude "add logging to order service based on patterns"
claude "add logging to payment service based on patterns"

Przebieg weryfikacji (nadal używający cache)
Okno terminala
```
claude "verify logging consistency across all services"
```

Wzorzec 3: Rozwój oparty na szablonach

Twórz cache’owane szablony dla typowych operacji:

# Cache'uj kontekst szablonu
claude "analyze our API patterns" templates/api-template.ts

# Używaj ponownie dla wielu endpointów (90% taniej każdy)
claude "create user endpoint following template"
claude "create order endpoint following template"
claude "create payment endpoint following template"

Wzorce optymalizacji przepływu pracy

Grupowanie dla efektywności

Wzorzec 1: Grupowe aktualizacje wielu plików

# NIEEFEKTYWNE: Wiele oddzielnych operacji
claude "update user model" models/user.ts
claude "update user service" services/user.ts
claude "update user controller" controllers/user.ts
claude "update user tests" tests/user.test.ts

# EFEKTYWNE: Pojedyncza skoordynowana operacja
claude "add email verification to user system" \
  models/user.ts \
  services/user.ts \
  controllers/user.ts \
  tests/user.test.ts \
  --plan "1. Add emailVerified field 2. Add verification service 3. Add endpoints 4. Update tests"

Wzorzec 2: Inteligentne okienkowanie kontekstu

Strategicznie zarządzaj oknem kontekstu:

// Skrypt niestandardowego 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

Stwórz system śledzenia tokenów:

#!/bin/bash
# Owijka claude-code do śledzenia użycia
claude_tracked() {
  local start_time=$(date +%s)
  local temp_log=$(mktemp)

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

  # Wyodrębnij użycie tokenów (zakłada, że claude-code wyświetla 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

  # Posprzątaj
  rm "$temp_log"
}

alias claude-code="claude_tracked"

Pulpit 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 dziennych kosztów
    daily_cost = df.groupby('date')['cost'].sum()

    # Efektywność tokenów (cache'owane 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żyj odpowiedniego modelu do zadania:

# Złożona refaktoryzacja: Użyj Sonnet
CLAUDE_MODEL=claude-sonnet-4.5 claude "refactor authentication system"

# Proste poprawki: Można użyć Haiku (gdy dostępny w CLI)
CLAUDE_MODEL=claude-haiku claude "fix typo in README"

# Przegląd kodu: Opus dla najgłębszej analizy
CLAUDE_MODEL=claude-opus-4.5 claude "security audit auth system"

Przetwarzanie przyrostowe

Podziel duże zadania na części efektywne tokenowo:

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

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

    // Przetwórz partię z ukierunkowanym kontekstem
    await claudeCode([
      'migrate to 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

“Zmniejszyliśmy zadanie refaktoryzacji o 2 milionach tokenów do 400K tokenów (80% redukcji) używając tych technik:”

Faza wstępnej analizy
- Przeprowadziliśmy analizę statyczną w celu identyfikacji rzeczywistych zależności
- Stworzyli wykres zależności w celu optymalizacji dołączania kontekstu
- Koszt: 50K tokenów
Podzielona refaktoryzacja
- Podzieliliśmy na 20 niezależnych części na podstawie analizy zależności
- Każda część używała tylko odpowiedniego kontekstu
- Koszt: 300K tokenów (vs 1.5M z pełnym kontekstem)
Przebieg weryfikacji
- Pojedynczy przebieg z cache’owanymi wzorcami refaktoryzacji
- Weryfikacja spójności we wszystkich zmianach
- Koszt: 50K tokenów (90% z cache)

Studium przypadku: Codzienny przepływ pracy developera

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

Przed
Po

# Przygotowanie do standup: 100K tokenów
claude "summarize all yesterday's changes" .

# Rozwój funkcji: 500K tokenów
claude "implement user dashboard" src/

# Naprawy bugów: 300K tokenów
claude "fix all linting errors" .

# Razem: 900K tokenów/dzień ($3.60)

# Przygotowanie do standup: 20K tokenów
claude "summarize changes" --since yesterday --format brief

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

# Naprawy bugów: 50K tokenów
claude "fix critical lints only" --severity error

# Razem: 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 inteligentniejszej pracy, a nie cięższej. Rozumiejąc ekonomię tokenów, wykorzystując cache’owanie i strukturyzując przepływy pracy efektywnie, możesz zmniejszyć koszty o 80% lub więcej, jednocześnie faktycznie poprawiając prędkość rozwoju. Kluczem jest traktowanie tokenów jako cennego zasobu i optymalizowanie ich użycia tak samo, jak optymalizowałbyś wydajność kodu.