Przejdź do głównej zawartości
Developer Toolkit Developer Toolkit Cursor & Claude Code | Developer Toolkit

Strategie dla milionowych linii kodu

Nawigowanie po milionowych kodach źródłowych przypomina eksplorację rozległego miasta bez mapy. Każda zmiana wywołuje fale w niezliczonych zależnościach, a zrozumienie pełnego wpływu wymaga nadludzkiej pamięci. Ten przewodnik pokazuje, jak asystenci kodowania AI przekształcają tę złożoność w zarządzalne przepływy pracy.

Wyzwanie skali

Dział zatytułowany „Wyzwanie skali”

Gdy kod źródłowy przekracza próg miliona linii, tradycyjne podejścia do rozwoju przestają działać. Masz do czynienia z:

  • Przeciążeniem poznawczym: Żaden pojedynczy programista nie może utrzymać całej architektury systemu w głowie
  • Ukrytym powiązaniem: Zależności zakopane głęboko przez granice modułów
  • Archeologią legacy: Kod napisany przez programistów, którzy odeszli lata temu
  • Wąskimi gardłami wydajności: IDE i narzędzia, które się zacinają przy samej objętości
  • Fragmentacją kontekstu: Różne zespoły z różnymi konwencjami i wzorcami

Rozwiązaniem nie jest cięższa praca - to wykorzystanie asystentów AI, którzy mogą przetwarzać i rozumieć kod na skalę maszynową, podczas gdy ty skupiasz się na decyzjach architektonicznych.

Dlaczego AI doskonale radzi sobie ze skalą

Dział zatytułowany „Dlaczego AI doskonale radzi sobie ze skalą”

Nieograniczona pamięć robocza

Podczas gdy ludzie mają problemy z 7±2 elementami w pamięci roboczej, modele AI mogą analizować setki plików jednocześnie, śledząc zależności, których nigdy nie dostrzegłbyś ręcznie.

Zrozumienie semantyczne

AI nie tylko przeszukuje ciągów znaków - rozumie intencję kodu, znajdując koncepcyjnie powiązane funkcje przez różne konwencje nazewnictwa i implementacje.

Wykrywanie wzorców na skalę

Identyfikuje anty-wzorce, zduplikowaną logikę i możliwości optymalizacji, których odkrycie zajęłoby miesiące ręcznego przeglądu kodu.

Bezstrachowy refactoring

Wykonuj rozległe zmiany w tysiącach plików z pewnością, podczas gdy AI śledzi wszystkie wpływy i sugeruje niezbędne dostosowania.

Podstawowe serwery MCP dla dużych kodów źródłowych

Dział zatytułowany „Podstawowe serwery MCP dla dużych kodów źródłowych”

Zanim przejdziemy do strategii, potrzebujesz odpowiednich narzędzi. Te serwery MCP przekształcają sposób, w jaki asystenci AI rozumieją i nawigują po masywnych kodach źródłowych:

Semantyczne wyszukiwanie kodu: Zilliz Code Context

Dział zatytułowany „Semantyczne wyszukiwanie kodu: Zilliz Code Context”

Gdy masz do czynienia z milionami linii, tradycyjne wyszukiwanie tekstowe zawodzi. Potrzebujesz zrozumienia semantycznego.

Instalacja dla Claude Code:

Okno terminala
claude mcp add code-context -e OPENAI_API_KEY=your-api-key -e MILVUS_TOKEN=your-zilliz-key -- npx @zilliz/code-context-mcp@latest

Instalacja dla Cursor: Dodaj do ~/.cursor/mcp.json:

{
  "mcpServers": {
    "code-context": {
      "command": "npx",
      "args": ["-y", "@zilliz/code-context-mcp@latest"],
      "env": {
        "EMBEDDING_PROVIDER": "OpenAI",
        "OPENAI_API_KEY": "your-api-key",
        "MILVUS_TOKEN": "your-zilliz-key"
      }
    }
  }
}

Ten serwer używa embeddingów wektorowych do semantycznego rozumienia kodu. Zapytaj “znajdź wszystkie przepływy uwierzytelniania”, a zrozumie koncepcję przez różne implementacje - czy to OAuth, JWT, czy oparte na sesjach.

Wysokowydajne wyszukiwanie wzorców: Ripgrep MCP

Dział zatytułowany „Wysokowydajne wyszukiwanie wzorców: Ripgrep MCP”

Do błyskawicznego dopasowywania regex i wzorców w masywnych kodach źródłowych:

Instalacja dla Claude Code:

Okno terminala
claude mcp add-json "ripgrep" '{"command":"npx","args":["-y","mcp-ripgrep@latest"]}'

Przykład użycia:

"Użyj ripgrep, aby znaleźć wszystkie komentarze TODO o wysokim priorytecie w kodzie źródłowym"
"Szukaj wszystkich zapytań SQL, które mogą być podatne na iniekcje"
"Znajdź wszystkie endpointy API, które nie mają ograniczenia częstotliwości"

Lokalne indeksowanie kodu: Wyszukiwanie z zachowaniem prywatności

Dział zatytułowany „Lokalne indeksowanie kodu: Wyszukiwanie z zachowaniem prywatności”

Dla wrażliwych kodów źródłowych przedsiębiorstw, które nie mogą korzystać z usług chmurowych:

Luoto Local Code Search używa ChromaDB do lokalnego wyszukiwania wektorowego:

Okno terminala
# Konfiguruj środowisko
PROJECTS_ROOT=~/enterprise/code
FOLDERS_TO_INDEX=core-services,payment-engine,user-platform


# Dodaj do Cursor
claude mcp add-json "workspace-code-search" '{"url":"http://localhost:8978/sse"}'

To utrzymuje kod lokalnie, zapewniając jednocześnie możliwości wyszukiwania semantycznego - kluczowe dla usług finansowych, opieki zdrowotnej czy wykonawców obronnych.

Przepływy pracy odkrywania architektury

Dział zatytułowany „Przepływy pracy odkrywania architektury”

Odziedziczyłeś 3-milionowy monolit. Od czego w ogóle zacząć? Oto sprawdzone w boju podejście:

Faza 1: Rekonesans na wysokim poziomie

Dział zatytułowany „Faza 1: Rekonesans na wysokim poziomie”

Zacznij od szerokiego zrozumienia architektonicznego:

"Przeanalizuj ten kod źródłowy i stwórz model mentalny architektury systemu.
Skup się na:
1. Głównych domenach biznesowych
2. Granicach usług
3. Wzorcach przepływu danych
4. Zależnościach zewnętrznych


Przedstaw jako przegląd wysokiego poziomu odpowiedni dla nowego starszego inżyniera."

Następnie zagłęb się w konkretne obszary:

"Używając wyszukiwania code-context, znajdź wszystkie przepływy przetwarzania płatności.
Muszę zrozumieć:
- Punkty wejścia dla żądań płatności
- Zarządzanie stanem podczas przetwarzania
- Integrację z zewnętrznymi dostawcami płatności
- Obsługę błędów i logikę ponownych prób"

Faza 2: Mapowanie zależności

Dział zatytułowany „Faza 2: Mapowanie zależności”

Zrozumienie, jak moduły się łączą, jest kluczowe dla bezpiecznego refactoringu:

"Utwórz wykres zależności dla modułu UserService:
1. Od jakich usług zależy?
2. Jakie usługi od niego zależą?
3. Czy są jakieś zależności cykliczne?
4. Które zależności wyglądają problematycznie lub są silnie sprzężone?"

Kontynuuj konkretnymi badaniami:

"UserService zależy od 47 innych usług.
Pomóż mi zidentyfikować, które zależności są rzeczywiście niezbędne
vs. które można zrefaktoryzować do używania zdarzeń lub interfejsów."

Zarządzanie kontekstem na skalę

Dział zatytułowany „Zarządzanie kontekstem na skalę”

Największy błąd, jaki popełniają programiści z dużymi kodami źródłowymi? Próbowanie załadowania wszystkiego naraz. Twój asystent AI nie musi widzieć wszystkich 3 milionów linii - potrzebuje odpowiedniego kontekstu w odpowiednim czasie.

Strategia hierarchii kontekstu

Dział zatytułowany „Strategia hierarchii kontekstu”

Myśl o kontekście jak o przybliżaniu na mapie. Zacznij od widoku kontynentu, potem kraj, potem miasto, potem ulica:

  1. Poziom domeny (widok z 10 000 stóp)

    "Jakie są główne konteksty ograniczone w tym systemie?"
    "Jak domeny płatności, użytkowników i inwentarza oddziałują?"

  2. Poziom usługi (widok z 1000 stóp)

    "W domenie płatności wyjaśnij architekturę usług"
    "Jakie są główne API udostępniane przez usługi płatności?"

  3. Poziom komponentu (widok ze 100 stóp)

    "Pokaż mi, jak PaymentProcessor obsługuje transakcje kartą kredytową"
    "Jaka jest strategia ponownych prób dla nieudanych płatności?"

  4. Poziom implementacji (poziom gruntu)

    "W PaymentProcessor.processCard(), dlaczego jest timeout 30 sekund?"
    "Czy powinniśmy zrefaktoryzować ten zsynchronizowany blok?"

Wzorce inteligentnego ładowania kontekstu

Dział zatytułowany „Wzorce inteligentnego ładowania kontekstu”

Wzorzec 1: Hierarchiczne pliki CLAUDE.md

/CLAUDE.md                        # Konwencje całego systemu
/services/CLAUDE.md               # Wzorce warstwy usług
/services/payment/CLAUDE.md       # Reguły specyficzne dla płatności
/services/payment/core/CLAUDE.md  # Reguły podstawowej logiki płatności

Każdy poziom dziedziczy od swojego rodzica, tworząc ukierunkowany kontekst:

# W /services/payment/CLAUDE.md
Ta usługa obsługuje całe przetwarzanie płatności.
kluczowe zasady:
- Wszystkie kwoty w centach, aby uniknąć liczb zmiennoprzecinkowych
- Klucze idempotentności wymagane dla wszystkich transakcji
- Zgodność PCI: nigdy nie loguj pełnych numerów kart


Wspólne wzorce w tej usłudze:
- Wzorzec repozytorium dla dostępu do danych
- Wzorzec poleceń dla operacji płatności
- Event sourcing dla historii transakcji

Wzorzec 2: Polecenia przełączania kontekstu

# Wyczyść kontekst między niepowiązanymi zadaniami
/clear


# Pracuj nad systemem płatności
/add services/payment
"Przeanalizuj przepływ przetwarzania płatności"


# Przełącz na system użytkowników
/clear
/add services/users
"Przejrzyj implementację uwierzytelniania"

Techniki optymalizacji kontekstu

Dział zatytułowany „Techniki optymalizacji kontekstu”

Reguła 80/20 dla kontekstu
80% twoich pytań potrzebuje tylko 20% kodu źródłowego. Nie zaśmiecaj kontekstu rzadko używanymi narzędziami:

# Źle: Ładowanie wszystkiego
"Załaduj cały kod i znajdź problemy z wydajnością"


# Dobrze: Ukierunkowane ładowanie
"W potoku przetwarzania zamówień (services/orders/pipeline/),
zidentyfikuj wąskie gardła w Order.process() przez Order.ship()"

Progresywne rozszerzanie kontekstu
Zacznij wąsko i rozszerzaj tylko gdy potrzeba:

# Krok 1: Zrozum problem
@OrderService.java "Dlaczego przetwarzanie zamówień trwa 5+ sekund?"


# Krok 2: Rozszerz na powiązane usługi
@orders/ @inventory/ "Czy opóźnienie wynika ze sprawdzeń inwentarza?"


# Krok 3: Włącz infrastrukturę
@orders/ @database/migrations/ @config/
"Czy to może być problem z indeksowaniem bazy danych?"

Przepływy pracy refactoringu przyrostowego

Dział zatytułowany „Przepływy pracy refactoringu przyrostowego”

Refactoring milionowego kodu źródłowego to jak renowacja szpitala podczas trwania operacji. Nie możesz wszystkiego wyłączyć do przepisania. Oto jak wprowadzać systematyczne ulepszenia bezpiecznie:

Studium przypadku: Migracja z callbacków na async/await

Dział zatytułowany „Studium przypadku: Migracja z callbacków na async/await”

Twój kod źródłowy Node.js ma 50 000 funkcji callback. Ręczna migracja zajęłaby lata. Oto podejście wspomagane przez AI:

Faza 1: Odkrywanie i planowanie

"Używając ripgrep, znajdź wszystkie wzorce callback w kodzie źródłowym.
Skategoryzuj je według:
1. Proste callbacki (pojedyncza operacja asynchroniczna)
2. Łańcuchy callbacków (wiele sekwencyjnych operacji)
3. Równoległe callbacki (wiele współbieżnych operacji)
4. Callbacki error-first z złożoną obsługą błędów
5. Callbacki ze współdzielonym stanem lub domknięciami


Wygeneruj raport złożoności migracji."

Przykładowa odpowiedź:

Znaleziono 47 832 wzorce callback:
- Proste callbacki: 31 245 (65%) - Niskie ryzyko
- Łańcuchy callbacków: 9 823 (21%) - Średnie ryzyko
- Równoległe callbacki: 4 234 (9%) - Wysokie ryzyko
- Złożona obsługa błędów: 1 830 (4%) - Wysokie ryzyko
- Callbacki ze współdzielonym stanem: 700 (1%) - Bardzo wysokie ryzyko


Zalecana kolejność migracji: Zacznij od prostych callbacków
w funkcjach narzędziowych, potem przejdź do warstwy usług...

Faza 2: Tworzenie wzorców migracji

"Dla każdego typu wzorca callback utwórz bezpieczny szablon migracji.
Uwzględnij:
1. Wzorzec transformacji
2. Przypadki graniczne, na które należy zwrócić uwagę
3. Strategię testowania
4. Plan wycofania"

AI generuje wzorce wielokrotnego użytku:

// Przed
function loadUser(id, callback) {
  db.query('SELECT * FROM users WHERE id = ?', [id], (err, result) => {
    if (err) return callback(err);
    callback(null, result[0]);
  });
}


// Po (z kompatybilnością wsteczną)
async function loadUser(id, callback) {
  // Obsługuj zarówno styl callback jak i promise
  if (callback) {
    try {
      const result = await db.query('SELECT * FROM users WHERE id = ?', [id]);
      callback(null, result[0]);
    } catch (err) {
      callback(err);
    }
  } else {
    const result = await db.query('SELECT * FROM users WHERE id = ?', [id]);
    return result[0];
  }
}

Faza 3: Zautomatyzowana migracja

"Używając wzorców migracji, przekształć wszystkie proste callbacki
w katalogu utils/. Dla każdego pliku:
1. Zastosuj transformację
2. Zachowaj kompatybilność wsteczną
3. Dodaj komentarze deprecation
4. Aktualizuj lub utwórz testy
5. Śledź status migracji"

Strategia równoległego refactoringu

Dział zatytułowany „Strategia równoległego refactoringu”

Dla masywnych wysiłków refactoringu, koordynuj wiele instancji AI:

  1. Podziel kod źródłowy

    "Przeanalizuj zależności modułów i zasugeruj, jak podzielić
    kod źródłowy do równoległego refactoringu przez 4 programistów.
    Minimalizuj konflikty między zespołami."

  2. Utwórz gałęzie funkcji

    Okno terminala
    git checkout -b refactor/team1-user-services
    git checkout -b refactor/team2-payment-services
    git checkout -b refactor/team3-inventory-services
    git checkout -b refactor/team4-shared-utils

  3. Synchronizuj postęp

    "Przejrzyj zmiany we wszystkich gałęziach refactor/*.
    Zidentyfikuj potencjalne konflikty lub zmiany łamiące
    między pracą zespołów."

  4. Testowanie integracji

    "Wygeneruj testy integracji, które weryfikują, czy zrefaktoryzowane
    moduły działają prawidłowo razem. Skup się na interakcjach
    granicznych między terytoriami zespołów."

Przepływy pracy optymalizacji wydajności

Dział zatytułowany „Przepływy pracy optymalizacji wydajności”

W milionowych kodach źródłowych problemy z wydajnością kryją się w nieoczekiwanych miejscach. Niewinnie wyglądająca funkcja wywołana w ciasnej pętli może zwalić cały system. Oto jak systematycznie polować na problemy z wydajnością i je naprawiać:

Przepływ pracy audytu wydajności

Dział zatytułowany „Przepływ pracy audytu wydajności”

Krok 1: Analiza złożoności algorytmicznej

"Używając analizy kodu, znajdź wszystkie potencjalne algorytmy O(n²) lub gorsze.
Dla każdego określ:
1. Jak często jest wywoływany
2. Typowy rozmiar wejścia
3. Czy jest na ścieżce krytycznej
4. Sugerowane podejście do optymalizacji"

Przykładowe odkrycia:

Znaleziono 47 potencjalnych algorytmów kwadratowych:


KRYTYCZNE - UserMatcher.findDuplicates()
- Wywoływany przy każdej rejestracji użytkownika
- Przetwarza 2,3M użytkowników
- Obecny czas: ~18 sekund
- Naprawa: Użyj podejścia opartego na hash, zmniejszając do O(n)


WYSOKIE - ReportGenerator.crossTabulate()
- Wywoływany w nocnych zadaniach wsadowych
- Przetwarza macierz 100K x 100K
- Obecny czas: ~4 godziny
- Naprawa: Użyj reprezentacji macierzy rzadkiej

Wzorce wydajności bazy danych

Dział zatytułowany „Wzorce wydajności bazy danych”

Zabójca wydajności #1 w dużych aplikacjach? Zapytania bazy danych. Oto systematyczne podejście:

"Przeanalizuj kod źródłowy pod kątem anty-wzorców wydajności bazy danych:
1. Zapytania N+1 w użyciu ORM
2. Brakujące indeksy na kluczach obcych
3. Zapytania bez paginacji
4. Niepotrzebne eager loading
5. Zapytania wewnątrz pętli


Dla każdego znalezionego problemu podaj:
- Lokalizację w kodzie
- Szacunkowy wpływ na wydajność
- Konkretną naprawę z przykładem kodu"

AI identyfikuje:

// Problem: zapytania N+1 w OrderService
async function getOrdersWithItems(userId) {
  const orders = await Order.findAll({ where: { userId } });


  // To tworzy zapytania N+1!
  for (const order of orders) {
    order.items = await OrderItem.findAll({
      where: { orderId: order.id }
    });
  }
  return orders;
}

Sugerowana naprawa:

// Rozwiązanie: Użyj eager loading
async function getOrdersWithItems(userId) {
  const orders = await Order.findAll({
    where: { userId },
    include: [{
      model: OrderItem,
      as: 'items'
    }]
  });
  return orders;
}


// Lub użyj surowego SQL dla złożonych przypadków
async function getOrdersWithItemsOptimized(userId) {
  const query = `
    SELECT o.*,
           JSON_AGG(oi.*) as items
    FROM orders o
    LEFT JOIN order_items oi ON oi.order_id = o.id
    WHERE o.user_id = $1
    GROUP BY o.id
  `;
  return await db.query(query, [userId]);
}

Wykrywanie wycieków pamięci

Dział zatytułowany „Wykrywanie wycieków pamięci”

Wycieki pamięci w dużych aplikacjach są podstępne. Budują się powoli, aż serwery zaczynają się crashować:

"Szukaj typowych wzorców wycieków pamięci:
1. Event listenery bez czyszczenia
2. Domknięcia trzymające duże obiekty
3. Referencje cykliczne
4. Rosnące cache bez limitów
5. Timery, które nigdy się nie czyszczą


Skup się na długotrwałych usługach i workerach w tle."

AI znajduje problemy takie jak:

// Wyciek pamięci w WebSocketManager
class WebSocketManager {
  constructor() {
    this.connections = new Map();
  }


  addConnection(userId, socket) {
    // WYCIEK: Stare połączenia nigdy nie usuwane!
    this.connections.set(userId, socket);


    socket.on('message', (data) => {
      // WYCIEK: Domknięcie trzyma referencję do całego managera
      this.handleMessage(userId, data);
    });
  }
}


// Naprawa z odpowiednim czyszczeniem
class WebSocketManager {
  constructor() {
    this.connections = new Map();
  }


  addConnection(userId, socket) {
    // Usuń istniejące połączenie
    this.removeConnection(userId);


    const messageHandler = (data) => {
      this.handleMessage(userId, data);
    };


    socket.on('message', messageHandler);
    socket.on('close', () => this.removeConnection(userId));


    this.connections.set(userId, {
      socket,
      handlers: { message: messageHandler }
    });
  }


  removeConnection(userId) {
    const conn = this.connections.get(userId);
    if (conn) {
      conn.socket.removeAllListeners();
      this.connections.delete(userId);
    }
  }
}

Archeologia kodu legacy

Dział zatytułowany „Archeologia kodu legacy”

Każdy duży kod źródłowy ma swoje warstwy archeologiczne - kod napisany w różnych epokach, przez różne zespoły, z różnymi filozofiami. Część z niego poprzedza kontrolę wersji. Oto jak bezpiecznie wykopywać i modernizować:

Dekodowanie starożytnych tekstów

Dział zatytułowany „Dekodowanie starożytnych tekstów”

Odkryłeś 15 000-liniową procedurę składowaną, która obsługuje cały system rozliczeniowy. Nikt jej nie rozumie, ale przetwarza 10 milionów dolarów dziennie. Oto podejście:

Metoda archeologiczna

"Przeanalizuj tę procedurę składowaną (billing_mega_proc.sql) i:
1. Utwórz diagram przepływu wysokiego poziomu
2. Wyodrębnij główne reguły biznesowe
3. Zidentyfikuj główne transformacje danych
4. Znajdź wszelkie ukryte efekty uboczne
5. Zasugeruj, jak rozłożyć to na usługi


Traktuj to jak inżynierię wsteczną obcego artefaktu.
Bądź bardzo ostrożny z subtelną logiką biznesową."

AI odpowiada strukturalną analizą:

Analiza billing_mega_proc.sql:


ODKRYTE GŁÓWNE REGUŁY BIZNESOWE:
1. Ceny poziomowe z 47 szczególnymi przypadkami
2. Zniżki dla legacy klientów (niektóre zakodowane na sztywno według ID!)
3. Złożone obliczanie podatków z wariantami regionalnymi
4. Generowanie ścieżki audytu (pisze do 6 różnych tabel)


UKRYTE ZACHOWANIA:
- Wysyła maile bezpośrednio z bazy danych (!)
- Aktualizuje inwentarz jako efekt uboczny
- Tworzy wpisy księgowe
- Ma nieudokumentowany "tryb debug" gdy user_id = 1


STRATEGIA DEKOMPOZYCJI:
1. Wyodrębnij silnik cenowy (pure functions)
2. Oddzielny serwis kalkulatora podatków
3. Przenies wysyłanie maili do kolejki wiadomości
4. Utwórz odpowiedni serwis audytu

Podejście Strangler Fig

Dział zatytułowany „Podejście Strangler Fig”

Zamiast przepisywać wszystko na raz, stopniowo dłavić legacy system:

"Utwórz nowoczesną bramę API, która opakuje legacy system rozliczeniowy.
Wymagania:
- Endpointy RESTful dla wszystkich operacji rozliczeniowych
- Nadal wywoływaj legacy procedurę składowaną wewnętrznie
- Dodaj odpowiednią obsługę błędów i logowanie
- Zwróć spójne odpowiedzi JSON
- Dodaj dokumentację OpenAPI"

To daje ci:

// Nowoczesne API opakowujące legacy system
@Post('/billing/calculate')
async calculateBilling(@Body() request: BillingRequest) {
  try {
    // Nadal wywołuje potworną procedurę składowaną
    const result = await this.db.callProcedure(
      'billing_mega_proc',
      request.customerId,
      request.items,
      request.date
    );


    // Przekształć krypticzną odpowiedź na nowoczesny format
    return {
      success: true,
      invoice: this.transformLegacyInvoice(result),
      timestamp: new Date().toISOString()
    };
  } catch (error) {
    // Legacy proc zwraca błędy jako magiczne liczby
    const errorMessage = this.decodeLegacyError(error);
    throw new HttpException(errorMessage, 400);
  }
}

Zrozumienie poprzez testowanie

Dział zatytułowany „Zrozumienie poprzez testowanie”

Gdy dokumentacja nie istnieje, testy stają się dokumentacją:

"Ten legacy moduł nie ma testów ani dokumentacji.
Utwórz wszechstronną suite testów, która:
1. Dokumentuje obecne zachowanie przez nazwy testów
2. Ujmuje wszystkie przypadki graniczne, które możesz znaleźć
3. Testuje warunki błędów i ich magiczne liczby
4. Weryfikuje efekty uboczne


Testy powinny służyć jako żywa dokumentacja."

AI generuje testy charakteryzacyjne:

describe('Legacy OrderProcessor - Obecne zachowanie', () => {
  describe('Ścieżka szczęśliwa', () => {
    it('przetwarza standardowe zamówienie z pojedynczym elementem', async () => {
      // Dokumentuje obecne zachowanie
      const result = await processOrder({
        customerId: 123,
        items: [{ sku: 'WIDGET-1', quantity: 1 }]
      });


      expect(result.status).toBe(1); // Magiczna liczba: 1 = sukces
      expect(result.orderId).toMatch(/^ORD-\d{8}$/); // Format: ORD-YYYYMMDD
    });
  });


  describe('Przypadki graniczne - odkryte przez testowanie', () => {
    it('stosuje tajną 50% zniżkę dla klienta ID 777', async () => {
      // Nieudokumentowane zachowanie znalezione przez eksplorację!
      const result = await processOrder({
        customerId: 777, // Magiczny klient
        items: [{ sku: 'ANY-ITEM', quantity: 1, price: 100 }]
      });


      expect(result.totalPrice).toBe(50);
    });


    it('zawodzi z kodem błędu -99 gdy inwentarz jest ujemny', async () => {
      // Więcej magicznych liczb udokumentowanych
      const result = await processOrder({
        customerId: 123,
        items: [{ sku: 'OUT-OF-STOCK', quantity: 1 }]
      });


      expect(result.status).toBe(-99); // -99 = błąd inwentarza
    });
  });
});

Koordynacja między zespołami

Dział zatytułowany „Koordynacja między zespołami”

W milionowych kodach źródłowych różne zespoły posiadają różne terytoria. Wyzwanie? Wprowadzanie zmian obejmujących wiele domen bez wchodzenia sobie w drogę.

Tworzenie interfejsów zespołowych

Dział zatytułowany „Tworzenie interfejsów zespołowych”

Gdy zespół A musi zrozumieć kod zespołu B:

Generator kontraktów API

"Przeanalizuj usługę płatności (należącą do zespołu FinTech) i wygeneruj:
1. Specyfikację OpenAPI dla wszystkich endpointów
2. Schematy zdarzeń dla wszystkich publikowanych zdarzeń
3. Schematy baz danych dla współdzielonych tabel
4. Przykładowe żądania/odpowiedzi
5. Typowe scenariusze błędów i obsługę


Sformatuj to dla zespołu mobilnego, który musi się zintegrować."

To tworzy jasne granice:

# Wygenerowany payment-service-api.yaml
openapi: 3.0.0
info:
  title: Payment Service API
  version: 2.3.0
  contact:
    team: FinTech
    slack: #team-fintech


paths:
  /payments/process:
    post:
      summary: Przetwórz płatność
      description: |
        Obsługuje płatności kartą kredytową, PayPal i ACH.
        Idempotentne przy użyciu nagłówka X-Idempotency-Key.
      x-rate-limit: 100 żądań na minutę
      x-sla: 99.9% uptime, <500ms p99 latency

Analiza wpływu zależności

Dział zatytułowany „Analiza wpływu zależności”

Przed wprowadzeniem zmian łamiących:

"Muszę zrefaktoryzować metodę UserService.authenticate().
Przeanalizuj:
1. Wszystkie usługi, które wywołują tę metodę
2. Parametry, które przekazują
3. Jak obsługują odpowiedź
4. Jakie błędy oczekują
5. Wszelkie zależności pośrednie


Utwórz plan migracji, który nie zepsuje innych zespołów."

AI dostarcza szczegółowy raport wpływu:

Bezpośredni konsumenci UserService.authenticate():
1. APIGateway - 1,247 wywołań
   - Używa: uwierzytelnianie username/password
   - Oczekuje: {userId, token, expiresAt}
   - Obsługa błędów: Łapie tylko AuthError


2. MobileBackend - 892 wywołania
   - Używa: uwierzytelnianie tokenem biometrycznym
   - Oczekuje: {userId, token, refreshToken}
   - Obsługa błędów: Ma logikę ponawiania


3. AdminPortal - 234 wywołania
   - Używa: uwierzytelnianie tokenem SSO
   - Oczekuje: {userId, permissions[], token}
   - Obsługa błędów: Powraca do legacy auth


PLAN MIGRACJI:
1. Dodaj nową metodę authenticateV2() z nową sygnaturą
2. Aktualizuj authenticate() do wywoływania V2 wewnętrznie
3. Powiadom zespoły z 2-tygodniowym oknem migracji
4. Monitoruj użycie, pomagaj zespołom migrować
5. Zdeprecjonuj starą metodę po 30 dniach

Automatyczne generowanie dokumentacji

Dział zatytułowany „Automatyczne generowanie dokumentacji”

Utrzymuj dokumentację zsynchronizowaną z kodem:

"Wygeneruj diagram modelu C4 pokazujący:
- Kontekst: Jak system płatności pasuje do ekosystemu
- Kontener: Usługi w domenie płatności
- Komponent: Wewnętrzna struktura payment-processor
- Kod: Kluczowe klasy i ich relacje


Użyj składni PlantUML, więc jest wersjonowana."

AI generuje:

@startuml Payment System - Container Diagram
!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml


Person(customer, "Klient", "Dokonuje zakupów")
System_Ext(bank, "System bankowy", "Przetwarza transakcje")


System_Boundary(payment, "Domena płatności") {
  Container(api, "Payment API", "Node.js", "REST API dla operacji płatności")
  Container(processor, "Payment Processor", "Java", "Podstawowa logika płatności")
  Container(fraud, "Wykrywanie oszustw", "Python", "Sprawdzenia oszustw oparte na ML")
  ContainerDb(db, "Payment DB", "PostgreSQL", "Rekordy transakcji")
  Container(events, "Event Bus", "Kafka", "Zdarzenia płatności")
}


Rel(customer, api, "Dokonuje płatności", "HTTPS")
Rel(api, processor, "Przetwórz płatność", "gRPC")
Rel(processor, fraud, "Sprawdź oszustwo", "HTTP")
Rel(processor, bank, "Obciąż kartę", "ISO 8583")
Rel(processor, db, "Przechowaj transakcję", "SQL")
Rel(processor, events, "Opublikuj zdarzenia", "Kafka")
@enduml

Scenariusze ze świata rzeczywistego

Dział zatytułowany „Scenariusze ze świata rzeczywistego”

Rozprawmy się z rzeczywistymi wyzwaniami, z którymi spotkasz się w milionowych kodach źródłowych:

Scenariusz: Wyodrębnianie plątanej usługi

Dział zatytułowany „Scenariusz: Wyodrębnianie plątanej usługi”

Twoja logika powiadomień jest rozproszona w 47 różnych usługach. Czas ją wyodrębnić:

Proces wyodrębniania

"Faza 1 - Odkrywanie:
Używając wyszukiwania semantycznego, znajdź CAŁY kod związany z powiadomieniami:
- Wysyłanie emaili
- Wysyłka SMS
- Powiadomienia push
- Alerty w aplikacji
- Dostarczanie webhooków


Uwzględnij: planowanie, templating, logikę ponawiania i preferencje."

Po którym następuje:

"Faza 2 - Rozplątanie:
Dla każdego znalezionego fragmentu kodu powiadomień:
1. Jakich danych potrzebuje?
2. Jakie usługi wywołuje?
3. Co go wyzwala?
4. Jak obsługuje niepowodzenia?
5. Co by się zepsuło, gdybyśmy to przenieśli?


Utwórz wykres zależności."

Następnie systematycznie wyodrębnij:

"Faza 3 - Projektowanie usługi:
Zaprojektuj usługę powiadomień, która:
1. Obsługuje wszystkie obecne typy powiadomień
2. Dostarcza zunifikowane API
3. Zachowuje kompatybilność wsteczną
4. Skaluje się niezależnie
5. Zawiera strategię migracji


Wygeneruj specyfikację API i plan migracji."

Scenariusz: Migracja bazy danych bez przestojów

Dział zatytułowany „Scenariusz: Migracja bazy danych bez przestojów”

Twoja tabela użytkowników ma 500 milionów rzędów i potrzebuje shardingu:

"Przeanalizuj wzorce dostępu do naszej tabeli użytkowników:
1. Jakie zapytania trafiają do tej tabeli?
2. Jaki jest stosunek odczytu do zapisu?
3. Jak wykonywane są JOIN-y?
4. Jaka jest dystrybucja zapytań według user_id?
5. Czy są jakieś zapytania globalne?


Zaleć strategię shardingu na podstawie rzeczywistego użycia."

AI odkrywa:

Wyniki analizy:
- 89% zapytań filtruje według user_id
- 7% to zapytania analityczne (pełne skany tabel)
- 4% to zapytania admin (według email, telefon)


Zalecana strategia:
- Shard według user_id (oparty na hash, 64 shardy)
- Replikuj tabele lookup dla email/telefon
- Przenieś analitykę do repliki odczytu
- Użyj usługi routingu dla lokalizacji shardów

Scenariusz: Kryzys wydajności

Dział zatytułowany „Scenariusz: Kryzys wydajności”

Produkcja jest wolna. Masz 2 godziny na znalezienie i naprawę problemu:

"PILNE: Wydajność produkcji spadła o 70% w ostatniej godzinie.
Systematycznie zbadaj:
1. Ostatnie wdrożenia
2. Wolne zapytania bazy danych
3. Opóźnienia usług zewnętrznych
4. Wyczerpanie zasobów
5. Możliwe wycieki pamięci


Skup się na zmianach z ostatnich 24 godzin."

AI dostarcza strukturalne badanie:

Wyniki badania:


1. OSTATNIE WDROŻENIA (ostatnie 24h):
   - 14:30: Wdrożono order-service v2.3.1
   - 14:35: Rozpoczęła się degradacja wydajności
   - Korelacja: WYSOKA


2. ZMIANY KODU w v2.3.1:
   Znalezione w OrderProcessor.java:
   - Dodano nowy sprawdzacz oszustw wywołujący zewnętrzne API
   - Brak skonfigurowanego timeout!
   - Zewnętrzne API odpowiada w 30-60 sekund


3. NATYCHMIASTOWA NAPRAWA:
   Dodaj timeout do sprawdzania oszustw:
   ```java
   // W OrderProcessor.java linii 234
   FraudCheckResult result = fraudClient
     .checkFraud(order)
     .timeout(Duration.ofMillis(500)) // Dodaj to
     .onErrorReturn(FraudCheckResult.ALLOW); // Fail open
  1. DŁUGOTERMINOWA NAPRAWA:
    • Uczyń sprawdzanie oszustw asynchronicznym
    • Dodaj circuit breaker
    • Buforuj wyniki sprawdzania oszustw
## Przepływy pracy ciągłego doskonalenia


### Cotygodniowe sprawdzenia zdrowia kodu źródłowego

“Uruchom cotygodniową analizę zdrowia kodu źródłowego:

  1. Nowe code smells wprowadzone
  2. Zmiany pokrycia testami
  3. Ryzyko regresji wydajności
  4. Podatności bezpieczeństwa
  5. Akumulacja długu technicznego

Porównaj z ostatnim tygodniem i podkreśl trendy.”

### Proaktywne zarządzanie zależnościami

“Przeanalizuj wszystkie zależności pod kątem:

  1. Podatności bezpieczeństwa (CVE)
  2. Wersje przestarzałe
  3. Zmiany łamiące w nowych wersjach
  4. Problemy zgodności licencji
  5. Nieoutrzymywane pakiety

Utwórz priorytetowy plan aktualizacji z oceną ryzyka.”

## Kluczowe wnioski dla sukcesu z milionami linii


<CardGrid>
  <Card title="Odpowiednie narzędzie, odpowiednia praca" icon="wrench">
    Używaj wyszukiwania semantycznego (Zilliz) do zrozumienia, ripgrep do wzorców, lokalnego indeksowania dla wrażliwego kodu. Nie próbuj ładować milionów linii do kontekstu.
  </Card>


  <Card title="Wszystko przyrostowo" icon="rocket">
    Nigdy nie próbuj big-bang refactoringu. Używaj flag funkcji, dual writes i stopniowych rolloutów. Pozwól AI pomóc planować bezpieczne, przyrostowe zmiany.
  </Card>


  <Card title="Testy jako dokumentacja" icon="document">
    W systemach legacy wszechstronne testy stają się dokumentacją. Używaj AI do generowania testów charakteryzacyjnych, które przechwytują obecne zachowanie.
  </Card>


  <Card title="Partnerstwo człowiek + AI" icon="users">
    AI obsługuje pracę mechaniczną - znajdowanie wzorców, generowanie boilerplate, śledzenie zależności. Ludzie dostarczają wiedzę domenową i wizję architektoniczną.
  </Card>
</CardGrid>


Praca z milionowymi kodami źródłowymi nie musi być przytłaczająca. Z odpowiednimi narzędziami AI i przepływami pracy możesz nawigować, rozumieć i bezpiecznie modyfikować nawet najbardziej złożone systemy. Kluczem jest myślenie systematyczne i pozwolenie AI obsługiwać skalę, podczas gdy ty skupiasz się na strategii.