Wprowadzenie

Niezależnie od tego, czy tworzysz nowy projekt od podstaw, czy pracujesz z istniejącym kodem, właściwe wykorzystanie LLM może znacząco zwiększyć twoją produktywność, jakość kodu. To w dużej mierze również optymalizacja procesów wytwarzania oprogramowania. Niniejsza instrukcja, oparta na doświadczeniach praktyków, przedstawia sprawdzone metody skutecznego korzystania z LLM w procesie programowania i usprawniania pracy zespołów developerskich.

Tworzenie projektów od podstaw (Greenfield)

Krok 1: Dopracowanie pomysłu

Rozpocznij od wykorzystania konwersacyjnego LLM (np. ChatGPT-4o lub Claude) do szczegółowego opracowania swojego pomysłu:

1. Rozpocznij burzę mózgów używając następującego promptu:

Zadaj mi jedno pytanie dotyczące mojego pomysłu. Następnie zadawaj po jednym pytaniu, bazując na moich odpowiedziach, aby stworzyć szczegółową specyfikację techniczną. Cel: systematyczne opracowanie wszystkich aspektów projektu – architektura, dane, API, UX, bezpieczeństwo. Po każdej mojej odpowiedzi, zadaj kolejne jedno pytanie, które pogłębi specyfikację.

Oto mój pomysł:

<TWÓJ_POMYSŁ>

2. Podsumuj burzę mózgów po zakończeniu procesu:

Stwórz kompleksową specyfikację techniczną na podstawie naszej konwersacji. Uwzględnij:

– Wymagania funkcjonalne i niefunkcjonalne

– Architekturę systemu (komponenty, interfejsy)

– Model danych

– Przepływy użytkownika

– Strategię obsługi błędów

– Plan testów

Format: dokumentacja techniczna gotowa do implementacji.

3. Zapisz specyfikację jako `spec.md` w repozytorium projektu.

Krok 2: Planowanie

Wykorzystaj model rozumowania (Claude Opus, Claude 3.5 Sonnet, itp.) do stworzenia szczegółowego planu:

1. Dla podejścia TDD (Test-Driven Development):

Na podstawie załączonej specyfikacji:

1. Utwórz plan implementacji projektu podzielony na etapy

2. Podziel każdy etap na małe, testowalne zadania implementacyjne

3. Dla każdego zadania przygotuj prompt dla LLM, który:

   – Zawiera kontekst z poprzednich kroków

   – Definiuje testy, które należy napisać

   – Określa funkcjonalność do zaimplementowania

   – Wskazuje sposób integracji z istniejącym kodem

Format wyniku:

– Każdy prompt w bloku kodu markdown

– Zadania ponumerowane w logicznej kolejności implementacji

– Prompty zoptymalizowane pod kątem generowania implementacji TDD

<SPECYFIKACJA>

2. Dla podejścia bez TDD:

Na podstawie załączonej specyfikacji:

1. Utwórz plan implementacji projektu podzielony na etapy

2. Podziel każdy etap na małe, wykonalne zadania programistyczne

3. Dla każdego zadania przygotuj prompt dla LLM, który:

   – Zawiera niezbędny kontekst z poprzednich kroków

   – Jasno określa funkcjonalność do zaimplementowania

   – Definiuje oczekiwany format i strukturę kodu

   – Wskazuje sposób integracji z dotychczas wygenerowanym kodem

Format wyniku:

– Każdy prompt w bloku kodu markdown

– Zadania ponumerowane w logicznej kolejności implementacji

– Prompty skoncentrowane na tworzeniu modułowej, testowalnej implementacji

<SPECYFIKACJA>

3. Utwórz listę zadań do śledzenia postępu:

Utwórz plik todo.md z listą kontrolną zawierającą:

1. Wszystkie zidentyfikowane zadania z planu implementacji

2. Pogrupowane według etapów/komponentów

3. Z polami do oznaczania postępu ([ ])

4. Z oszacowaniem złożoności każdego zadania (1-5)

5. Z zależnościami między zadaniami

4. Zapisz plan promptów jako `prompt_plan.md` w repozytorium.

Krok 3: Wykonanie

Dostępnych jest wiele narzędzi do wykonania planu. Sukces zależy głównie od jakości planu z kroku 2.

Korzystanie z Claude:

1. Przygotuj początkowy kod szablonowy i skonfiguruj narzędzia.

2. Wklej prompt z planu do Claude.

3. Skopiuj wygenerowany kod do swojego IDE.

4. Uruchom kod i testy.

5. Jeśli działa, przejdź do następnego promptu.

6. Jeśli nie działa, użyj narzędzia jak [repomix](https://github.com/yamadashy/repomix) do przesłania bazy kodu do Claude w celu debugowania.

7. Powtarzaj proces.

Korzystanie z Aider:

1. Przygotuj początkowy kod szablonowy i skonfiguruj narzędzia.

2. Uruchom Aider (zawsze na nowej gałęzi).

3. Wklej prompt z planu do Aider.

4. Obserwuj jak Aider generuje kod.

5. Aider uruchomi testy lub możesz uruchomić aplikację, aby zweryfikować.

6. Jeśli działa, przejdź do następnego promptu.

7. Jeśli nie działa, przeprowadź sesję Q&A z Aider, aby naprawić problemy.

8. Powtarzaj proces.

Praca z istniejącym kodem (Non-greenfield)

Gdy pracujesz z istniejącym kodem, potrzebujesz nieco innego podejścia, skoncentrowanego na konkretnych zadaniach zamiast na całym projekcie.

Pozyskiwanie kontekstu

1. Wybierz narzędzie do analizy kodu:

   – Można użyć narzędzi jak [repomix](https://github.com/yamadashy/repomix) do ekstrakcji i kompresji kodu

   – Alternatywnie: rozszerzenia IDE, skrypty Bash/Python lub narzędzia CI/CD

2. Przygotuj kontekst kodu:

   – Zbierz istotne fragmenty kodu do pliku tekstowego

   – Usuń nieistotne fragmenty (biblioteki zewnętrzne, zasoby binarne)

   – Zdefiniuj hierarchię ważności plików i komponentów

3. Wykorzystaj narzędzia do przetwarzania kontekstu**:

   – Narzędzia jak [LLM CLI](https://github.com/simonw/LLM) mogą pomóc w organizacji promptów

   – Generator promptów oparty o szablony może ustandaryzować analizę kodu

Praktyczne przykłady

Analiza brakujących testów z Claude:

1. Przejdź do katalogu z kodem.

2. Użyj narzędzia do analizy kodu i ekstrakcji kontekstu (np. wykorzystanie własnych skryptów lub narzędzi jak [repomix](https://github.com/yamadashy/repomix)).

   – W artykule autor używa własnych komend w narzędziu `mise` (np. `mise run LLM:generate_missing_tests`), które są skonfigurowane w jego środowisku.

3. Przeanalizuj wygenerowany raport z brakującymi testami.

4. Skopiuj kontekst kodu i prompt dotyczący konkretnego brakującego testu.

5. Wklej go do Claude z prośbą o implementację testu.

6. Skopiuj wygenerowany kod z Claude do swojego IDE.

7. Uruchom testy.

8. Powtarzaj proces dla kolejnych brakujących testów.

Analiza brakujących testów z Aider:

1. Przejdź do katalogu z kodem.

2. Uruchom Aider (na nowej gałęzi).

3. Użyj narzędzia do analizy kodu i identyfikacji brakujących testów.

   – Możesz użyć gotowych skryptów, rozszerzeń IDE lub własnych narzędzi do analizy pokrycia testami.

4. Przeanalizuj raport o brakujących testach.

5. Wklej prompt dotyczący implementacji konkretnego brakującego testu do Aider.

6. Obserwuj jak Aider generuje kod testowy.

7. Uruchom testy.

8. Powtarzaj proces dla kolejnych brakujących testów.

Efektywne prompty

Poniżej znajdują się zoptymalizowane prompty do analizy i usprawniania istniejących baz kodu:

Przeprowadź szczegółowy przegląd kodu poniżej:

1. Zidentyfikuj potencjalne problemy w zakresie:

   – Poprawności logicznej

   – Wydajności

   – Bezpieczeństwa

   – Zgodności z konwencjami

   – Jakości i czytelności

2. Dla każdego problemu podaj:

   – Lokalizację (plik/linia)

   – Opis problemu

   – Rekomendowane rozwiązanie

   – Priorytet (krytyczny/wysoki/średni/niski)

3. Format odpowiedzi: dokument markdown z sekcjami dla różnych typów problemów, cytowaniem problematycznego kodu i konkretnymi sugestiami poprawek.

<KOD>

Generowanie Issues na GitHub

Przeanalizuj poniższy kod i utwórz listę issues w formacie GitHub:

1. Zidentyfikuj kluczowe problemy związane z:

   – Błędami logicznymi/funkcjonalnymi

   – Długiem technicznym

   – Brakami w implementacji

   – Wyzwaniami dotyczącymi skalowalności/bezpieczeństwa

2. Dla każdego issue utwórz wpis zawierający:

   – Tytuł: krótki, opisowy

   – Opis: szczegółowe wyjaśnienie problemu

   – Kontekst: gdzie występuje problem (plik/linia)

   – Proponowane rozwiązanie

   – Etykiety: bug/enhancement/technical-debt/etc.

   – Priorytet

3. Format odpowiedzi: lista gotowych do utworzenia GitHub issues w formacie markdown.

<KOD>

Brakujące testy

Przeanalizuj poniższy kod pod kątem pokrycia testami:

1. Zidentyfikuj kluczowe funkcjonalności i komponenty wymagające testów

2. Dla każdego brakującego testu określ:

   – Co dokładnie powinno być testowane (konkretna funkcja/klasa/moduł)

   – Scenariusze testowe do uwzględnienia (przypadki brzegowe, typowe użycie)

   – Propozycję implementacji testu z pseudokodem lub rzeczywistym kodem

   – Priorytet implementacji testu

3. Jeśli istniejące testy są niewystarczające, wskaż:

   – Brakujące przypadki testowe

   – Słabe punkty w obecnym pokryciu

   – Propozycje ulepszeń

4. Format odpowiedzi: dokument w stylu GitHub issues gotowy do implementacji przez programistę.

<KOD>

Pułapki i wyzwania

  1. Utrata kontroli nad projektem – łatwo jest „wyjść poza swoje narty” i stracić orientację w projekcie. Rozwiązaniem jest trzymanie się planu i częste testy.
  1. Czas oczekiwania – generowanie kodu przez LLM może wymagać czasu. Wykorzystaj ten czas produktywnie:

   – Rozpocznij burzę mózgów dla innego projektu

   – Przeanalizuj kod lub dokumentację

   – Planuj kolejne kroki

  1. Praca w pojedynkę – obecne interfejsy LLM są głównie jednoosobowe, co utrudnia współpracę zespołową.

Najlepsze praktyki

1. Planuj przed kodowaniem – poświęć czas na dokładne planowanie, nawet dla małych zadań.

2. Pracuj iteracyjnie – podziel projekty na małe, możliwe do przetestowania kroki.

3. Testuj wcześnie i często – wdrażaj testy jednostkowe dla każdego elementu funkcjonalności.

4. Zachowaj dokumentację – przechowuj specyfikację, plan promptów i listę zadań w repozytorium projektu.

5. Przygotuj środowisko – skonfiguruj odpowiednie boilerplate i narzędzia przed rozpoczęciem pracy z LLM.

6. Podążaj za swoim tempem – rób przerwy, gdy tracisz orientację w projekcie.

7. Eksperymentuj z narzędziami – wypróbuj różne narzędzia (Claude, Aider, Cursor, GitHub Workspace) i znajdź to, które najlepiej pasuje do twojego stylu pracy.