Strategie dla dużych baz kodu: wydajność na dużą skalę

Praca z dużymi bazami kodu (100K+ linii kodu) w Cursor wymaga konkretnych strategii do utrzymania wydajności i produktywności. Ten przewodnik obejmuje sprawdzone techniki od zespołów zarządzających milionami linii kodu.

Zrozumienie wyzwań skali

Wydajność indeksowania

Początkowe indeksowanie może zająć 15+ minut dla bardzo dużych projektów

Limity okna kontekstu

Nawet z 200K tokenów nie można zmieścić wszystkiego

Użycie pamięci

Duże projekty mogą zużywać 8GB+ RAM podczas ciężkich operacji

Dokładność wyszukiwania

Znajdowanie odpowiedniego kodu staje się trudniejsze wraz ze wzrostem baz kodu

Strategie optymalizacji

1. Inteligentna konfiguracja indeksowania

Skonfiguruj Cursor do indeksowania tylko tego, co ma znaczenie:

.cursorignore
Ustawienia indeksowania

# .cursorignore - wyklucz z indeksowania

# Artefakty budowy
dist/
build/
out/
.next/
target/

# Zależności
node_modules/
vendor/
packages/*/node_modules/

# Wygenerowane pliki
*.generated.ts
*.pb.go
schema.graphql

# Duże pliki danych
*.csv
*.json > 1MB
fixtures/

# Dokumentacja
docs/api/
*.pdf

# Snapshoty testów
__snapshots__/
*.snap

{
  "cursor.indexing.enabled": true,
  "cursor.indexing.exclude": [
    "**/node_modules/**",
    "**/dist/**",
    "**/*.min.js",
    "**/coverage/**"
  ],
  "cursor.indexing.include": [
    "src/**",
    "lib/**",
    "packages/*/src/**"
  ],
  "cursor.indexing.incrementalUpdate": true,
  "cursor.indexing.updateInterval": "5m"
}

2. Strategia workspace wielokorzeniowego

Dla monorepo lub architektur wieloserwisowych:

// workspace.code-workspace
{
  "folders": [
    {
      "name": "Frontend",
      "path": "./packages/frontend"
    },
    {
      "name": "Backend API",
      "path": "./packages/api"
    },
    {
      "name": "Biblioteki współdzielone",
      "path": "./packages/shared"
    },
    {
      "name": "Infrastruktura",
      "path": "./infrastructure"
    }
  ],
  "settings": {
    "cursor.workspacePriority": {
      "Frontend": 1,
      "Backend API": 2,
      "Biblioteki współdzielone": 3,
      "Infrastruktura": 4
    }
  }
}

3. Zarządzanie oknem kontekstu

Strategie pracy w limitach tokenów:

Podejście warstwowego kontekstu

// Poziom 1: kontekst bezpośredni (obecny plik + bezpośrednie zależności)
"@current @imports Zaktualizuj tę logikę uwierzytelniania"

// Poziom 2: kontekst modułu (powiązane pliki w tym samym module)
"@folder:src/auth Refaktoryzuj cały moduł uwierzytelniania"

// Poziom 3: kontekst podsystemu (szerszy widok architektoniczny)
"@folder:src/auth @folder:src/users @docs:architecture.md
Zaimplementuj SSO w systemach uwierzytelniania i użytkowników"

// Poziom 4: pełny system (używaj oszczędnie)
"Przeanalizuj całą bazę kodu pod kątem luk bezpieczeństwa"

Wzorce optymalizacji kontekstu

Zacznij wąsko Rozpocznij od najbardziej specyficznego możliwego kontekstu
Rozwijaj stopniowo Dodawaj kontekst tylko gdy AI potrzebuje więcej informacji
Używaj granic semantycznych Uwzględniaj całe moduły zamiast losowych plików
Najpierw wykorzystaj tryb Ask Użyj trybu Ask do zrozumienia przed włączeniem kontekstu
Czyść po zadaniach Rozpoczynaj świeże czaty dla nowych zadań, aby uniknąć zanieczyszczenia kontekstu

4. Dostrajanie wydajności

Konfiguracja pamięci

// Ustawienia wydajności Cursor
{
  "cursor.performance.memoryLimit": "8GB",
  "cursor.performance.maxWorkers": 4,
  "cursor.performance.cacheSize": "2GB",
  "cursor.performance.enableLazyLoading": true,
  "cursor.performance.garbageCollection": "aggressive"
}

Wybór modelu dla skali

Typ zadania	Zalecany model	Dlaczego
Szybkie edycje	Claude 4 Sonnet	Szybki, wydajny dla małych zmian
Duża refaktoryzacja	Claude 4 Sonnet	Dobra równowaga możliwości i szybkości
Złożona analiza	Gemini 2.5 Pro	Obsługuje masywne okna kontekstu
Planowanie architektury	Claude 4 Opus	Najlepsze rozumowanie dla złożonych decyzji
Polowanie na błędy	o3	Głębokie rozumowanie dla trudnych problemów

5. Strategie wyszukiwania

Skuteczne wzorce wyszukiwania

// Wyszukiwanie semantyczne konceptów
"Gdzie jest zaimplementowane uwierzytelnianie użytkownika?"

// Połączone z regex dla precyzji
"@search('function.*Auth') Pokaż wszystkie funkcje uwierzytelniania"

// Wyszukiwania z zakresem dla wydajności
"@folder:src/payments Znajdź logikę przetwarzania płatności"

// Historyczne wyszukiwanie dla kontekstu
"@git Jakie zmiany zostały wprowadzone w uwierzytelnianiu w ostatnim miesiącu?"

Budowanie modeli mentalnych

Twórz i utrzymuj dokumentację wysokiego poziomu:

# Mapa architektury systemu

## Główne serwisy
- **Serwis uwierzytelniania** - `/src/auth` - obsługuje całe uwierzytelnianie
- **Serwis użytkowników** - `/src/users` - zarządzanie użytkownikami i profilami
- **Serwis płatności** - `/src/payments` - integracja Stripe
- **Serwis analityki** - `/src/analytics` - śledzenie zdarzeń

## Kluczowe wzorce
- Wszystkie serwisy używają dependency injection
- Uwierzytelnianie przez tokeny JWT
- Dostęp do bazy danych przez repozytoria
- Zdarzenia publikowane przez kolejkę wiadomości

Scenariusze dużych baz kodu z prawdziwego świata

Scenariusz 1: monolit korporacyjny (2M+ LOC)

Firma fintech skutecznie zarządza swoim masywnym monolitem Java:

banking-system/
├── core/              (500K LOC)
├── modules/           (800K LOC)
│   ├── accounts/
│   ├── transactions/
│   ├── compliance/
│   └── reporting/
├── integrations/      (400K LOC)
├── shared/            (200K LOC)
└── tests/             (300K LOC)

{
  "workspaces": [
    // Otwórz tylko moduły, nad którymi pracujesz
    {"path": "./core", "active": false},
    {"path": "./modules/accounts", "active": true},
    {"path": "./shared", "active": true}
  ],
  "rules": [
    "Skup się na granicach modułów",
    "Używaj kontraktów interfejsów",
    "Minimalizuj zależności między modułami"
  ]
}

Scenariusz 2: konstelacja mikroserwisów (50+ serwisów)

Zarządzanie systemem rozproszonym z Cursor:

// Niestandardowy skrypt menedżera workspace
class WorkspaceManager {
  async switchContext(feature: string) {
    const requiredServices = await this.getFeatureDependencies(feature);

    // Zamknij niepotrzebne workspace
    await this.closeWorkspaces(
      this.openWorkspaces.filter(w => !requiredServices.includes(w))
    );

    // Otwórz wymagane serwisy
    await this.openWorkspaces(requiredServices);

    // Przygotuj kontekst Cursor
    await this.primeContext(feature);
  }

  async primeContext(feature: string) {
    // Stwórz dokument kontekstu
    const context = `
    Pracuję nad: ${feature}
    Zaangażowane serwisy: ${this.openWorkspaces.join(', ')}
    Kluczowe pliki: ${await this.getKeyFiles(feature)}
    Ostatnie zmiany: ${await this.getRecentChanges(feature)}
    `;

    // Zapisz do .cursor/context.md
    await fs.writeFile('.cursor/context.md', context);
  }
}

Scenariusz 3: projekt open source (Kubernetes - 1.5M+ LOC)

Strategie używane przez kontrybutorów:

Skupienie na komponencie

Pracuj nad jednym komponentem na raz (np. tylko scheduler)

Kontrakty interfejsów

Zrozum interfejsy przed implementacjami

Eksploracja oparta na testach

Używaj testów do zrozumienia zachowania

Integracja dokumentacji

Zachowuj dokumenty projektowe w kontekście Cursor

Zaawansowane techniki

1. Wzorzec lazy loading

// Nie ładuj wszystkiego na raz
class LazyContextLoader {
  private loaded = new Set<string>();

  async getContext(query: string) {
    const relevant = await this.findRelevantModules(query);

    for (const module of relevant) {
      if (!this.loaded.has(module)) {
        await this.loadModule(module);
        this.loaded.add(module);
      }
    }

    return this.buildContext(relevant);
  }
}

2. Partycjonowanie bazy kodu

Podziel swoją bazę kodu na logiczne partycje:

partitions:
  frontend:
    paths: [src/ui, src/components, src/styles]
    rules: frontend-rules.md

  backend:
    paths: [src/api, src/services, src/db]
    rules: backend-rules.md

  infrastructure:
    paths: [deploy, terraform, k8s]
    rules: infra-rules.md

  shared:
    paths: [src/shared, src/utils]
    rules: shared-rules.md

# Używaj partycji w promptach:
# "@partition:frontend Zaktualizuj dashboard użytkownika"

3. Przyrostowe zrozumienie

Buduj zrozumienie przyrostowo:

Zmapuj terytorium

"Stwórz mapę architektury tej bazy kodu na wysokim poziomie"

Zidentyfikuj punkty wejścia

"Jakie są główne punkty wejścia dla tej aplikacji?"

Śledź kluczowe przepływy

"Śledź przepływ logowania użytkownika od początku do końca"

Zrozum wzorce

"Jakie wzorce są używane konsekwentnie w tej bazie kodu?"

Dokumentuj odkrycia

"Stwórz przewodnik architektury na podstawie naszej eksploracji"

Monitorowanie wydajności

Metryki do śledzenia

// Monitoruj wydajność Cursor
interface PerformanceMetrics {
  indexingTime: number;        // Indeksowanie początkowe
  searchLatency: number;       // Średni czas wyszukiwania
  tokenUsage: number;         // Tokeny na zadanie
  memoryUsage: number;        // Zużycie RAM
  responseTime: number;       // Opóźnienie odpowiedzi AI
}

// Loguj i analizuj
class PerformanceMonitor {
  logMetric(metric: keyof PerformanceMetrics, value: number) {
    console.log(`[Cursor Perf] ${metric}: ${value}`);

    // Alarmuj o degradacji
    if (this.isDegraded(metric, value)) {
      this.alert(`Degradacja wydajności w ${metric}`);
    }
  }
}

Lista kontrolna optymalizacji

Skonfiguruj .cursorignore dla swojego projektu
Ustaw workspace wielokorzeniowe, jeśli dotyczy
Dostraj ustawienia pamięci na podstawie specyfikacji maszyny
Stwórz definicje partycji dla dużych baz kodu
Dokumentuj kluczowe wzorce architektoniczne
Ustaw monitorowanie wydajności
Przeszkol zespół w zarządzaniu kontekstem
Regularne czyszczenie nieużywanych workspace

Rozwiązywanie problemów z dużymi bazami kodu

Wolne indeksowanie

Rozwiązanie: Sprawdź .cursorignore, zmniejsz indeksowane ścieżki, uruchom ponownie Cursor

Brak pamięci

Rozwiązanie: Zwiększ limit pamięci, zamknij nieużywane workspace, użyj wykluczeń

Niedokładne sugestie

Rozwiązanie: Popraw wybór kontekstu, zaktualizuj dokumentację, używaj konkretnych trybów

Przekroczono limit tokenów

Rozwiązanie: Podziel na mniejsze zadania, użyj ukierunkowanego kontekstu, wykorzystaj tryb Ask

Podsumowanie najlepszych praktyk

Następne kroki

Opanuj te techniki dla dużych baz kodu:

Audytuj obecną konfigurację - sprawdź indeksowanie i wydajność
Zaimplementuj partycjonowanie - zdefiniuj logiczne granice
Optymalizuj użycie kontekstu - ćwicz ukierunkowany wybór kontekstu
Eksploruj przepływy pracy multi-repo - kontynuuj do następnej sekcji

Pamiętaj: cel to nie załadowanie wszystkiego do Cursor, ale załadowanie właściwych rzeczy we właściwym czasie. Opanuj to, a nawet milionowe bazy kodu staną się zarządzalne.