Przejdź do głównej zawartości

Efektywne wzorce współpracy człowiek-AI

Człowiek w pętli to developer, który w jednym zadaniu przechodzi przez trzy role: architekta, gdy powstaje plan, nadzorcy, gdy agent implementuje, i recenzenta, zanim zmiana trafi do commita. Dopasowanie roli do ryzyka zadania oddziela bezmyślną pieczątkę od wąskiego gardła i trzyma nieprzejrzany diff z dala od produkcji.

Jest 16:00, a agent właśnie przepisał twój moduł uwierzytelniania: piętnaście plików, 800 zmienionych linii. Kompiluje się, testy przechodzą, wygląda wiarygodnie, więc akceptujesz całość. Dwa tygodnie później odkrywasz, że przepisanie po cichu usunęło sprawdzanie CSRF, które było w oryginalnym kodzie. Nikt tego nie wychwycił, bo nikt naprawdę nie przeglądał.

Druga skrajność kosztuje tyle samo. Zatwierdzaj każdy pojedynczy zapis pliku, a spędzisz na nadzorowaniu agenta więcej czasu, niż zajęłoby ci samodzielne napisanie kodu. Czytanie każdej wygenerowanej linii miało sens, gdy diff pisał człowiek; nie przetrwa zderzenia z agentem, który pisze większość kodu.

Odpowiedzią nie jest więc ani ślepe zaufanie, ani ciągły nadzór. Zespoły, które dowożą stabilny kod wspomagany przez AI, skupiają się na bramkach — zatwierdzony plan, findings z recenzji agenta, merge, autoryzacja wdrożenia — a pomiędzy nimi pozwalają sesji sprawdzać własną pracę. Te bramki rozpisuje AI-native SDLC; ta strona mówi, kto przy nich stoi i co tam naprawdę robi.

  • Pętla planuj-wykonuj-przeglądaj z ludzką decyzją przy każdym przekazaniu
  • Prompt planistyczny, który zmusza agenta do ujawnienia założeń, zanim napisze kod
  • Kontrakt zakresu, który zatwierdzasz, zanim zostanie ruszony choć jeden plik
  • Prompt nadzorczy, który ogranicza wykonanie do jednego kroku możliwego do przejrzenia
  • Dwa prompty recenzenckie robiące różne rzeczy: jeden inwentaryzuje zmianę, drugi ją atakuje
  • Bramki właściwe narzędziom — punkty kontrolne Cursora, hooki Claude Code, przegląd PR w Codeksie — które wyłapują to, co umyka zmęczonym oczom

Twoja rola zmienia się w trakcie sesji, a każda zmiana to świadomy punkt kontrolny, a nie przeczucie. Rozpoznanie, w której właśnie jesteś, oszczędza czas i wychwytuje problemy, póki naprawienie ich jest tanie.

1. Architekt (planowanie)

Zanim powstanie jakikolwiek kod, to ty jesteś właścicielem wizji i planu. Dajesz agentowi wysokopoziomowe wymagania, każesz mu zbadać bazę kodu w trybie tylko do odczytu i krytycznie oceniasz proponowany plan. Spędź tu najwięcej czasu: błędy architektoniczne są najdroższe do naprawienia, a to twoje doświadczenie wyłapuje pominięte wymaganie, póki wyłapanie go nic nie kosztuje.

2. Nadzorca (wykonanie)

Agent implementuje, a ty monitorujesz. Dzielisz zatwierdzony plan na małe kroki, podajesz je po jednym i przeglądasz strumień zmian pod kątem czerwonych flag — plików, których nie powinien dotykać, podejścia, na które nikt się nie umawiał. Nie musisz rozumieć każdej linii w czasie rzeczywistym, ale jesteś ręką na kierownicy, a nie widzem patrzącym, jak materializuje się commit na 800 linii.

3. Recenzent (weryfikacja)

Zadanie jest skończone i to ty decydujesz, czy idzie dalej. Jesteś strażnikiem intencji i ryzyka, nie każdej wygenerowanej linii. Rutynowe diffy najpierw przechodzą warstwową recenzję agenta (REVIEW.md, Bugbot, claude-code-action albo recenzja Codex); czytasz plan, podsumowanie PR i to, co agent oflagował. Linia po linii przeglądasz kod regulowany lub krytyczny, albo gdy finding mówi, że zmiana może zepsuć zachowanie, wyciec dane lub złamać politykę. Agent przyspiesza tworzenie; merge i produkcja nadal należą do ciebie.

Oto pętla zastosowana do prawdziwego zadania — dodania limitowania zapytań per użytkownik do trasy API w Next.js — wraz z promptem, który operacjonalizuje każdą rolę.

  1. Architekt: proś o plan do przejrzenia, nie o kod.

    W trybie tylko do odczytu (Cursor Ask, Claude Code plan mode lub codex --sandbox read-only) zmuś agenta do zaplanowania i oznaczenia zgadywanek, zanim cokolwiek ruszy. Sekcja „Assumptions” jest tu tym, co naprawdę się opłaca: zamienia niewidoczne założenia w listę, którą poprawisz w trzydzieści sekund.

  2. Nadzorca: wykonaj jeden krok, potem się zatrzymaj.

    Zatwierdź plan, przełącz się na tryb wykonania i ogranicz agenta do pojedynczego kroku z twardym punktem kontrolnym, żeby przejrzeć zmiany, zanim ruszy dalej. To najtańsze lekarstwo na zmęczenie recenzenta: diff, który faktycznie przeczytasz, bije diff, który przelecisz wzrokiem.

  3. Recenzent: każ agentowi zaatakować własny diff.

    Zanim cokolwiek zaakceptujesz, zamień agenta w sceptycznego recenzenta jego własnej pracy, a potem przeczytaj wszystko jeszcze raz samodzielnie. Wymienienie konkretnych zagrożeń w prompcie znaczy więcej niż poproszenie o „recenzję” — to ta konkretna lista wyciąga findings, których ogólne pytanie nigdy nie ujawni.

Nie każdy moment zasługuje na równą uwagę. Praktyczna reguła brzmi: przerwanie jest tanie wcześnie i drogie późno, więc wydawaj je na sygnały, a nie na każdy zapis pliku.

Interweniuj natychmiast, gdy:

  • Agent zaczyna modyfikować pliki poza ustalonym zakresem
  • Agent usuwa kod bez wyjaśnienia dlaczego
  • Agent instaluje zależności, o których nie rozmawialiście
  • Agent pomija testy lub tłumi błędy
  • Podejście odbiega od planu

Monitoruj, ale nie przerywaj, gdy:

  • Agent pracuje nad dobrze zdefiniowanym zadaniem z listy zadań
  • Zmiany lądują w plikach, których się spodziewałeś
  • Agent uruchamia testy i iteruje nad niepowodzeniami
  • Agent podąża za wzorcami już ustalonymi w bazie kodu

Przeglądaj po zakończeniu, gdy:

  • Zadanie jest małe i dobrze ograniczone (pojedynczy plik, jasne kryteria akceptacji)
  • Pokrycie testami dotkniętego obszaru jest solidne
  • Agent pracuje w sandboxie

Ryzyko zadania ustawia domyślne zachowanie, a to domyślne zachowanie warto spisać dla zespołu:

Poziom ryzykaTyp zadaniaZalecane podejście
WysokiZmiany w auth, migracje danych, kod bezpieczeństwaZatwierdzaj każdy zapis pliku. Przeglądaj diffy linia po linii.
ŚredniNowe funkcjonalności, endpointy API, komponenty UIPozwól agentowi pracować, przejrzyj całość zmiany przed commitem.
NiskiFormatowanie, zmiana nazw, dokumentacja, dodawanie testówAutomatyczne zatwierdzanie lub tryb bezobsługowy. Przejrzyj wiadomość commita.

Kontrakt zakresu poniżej to najtańsza wersja wszystkich trzech list: każe agentowi zadeklarować, czego zamierza dotknąć, więc „poza ustalonym zakresem” staje się czymś, co możesz sprawdzić, a nie czymś, co zauważasz po fakcie.

Pętla jest wszędzie taka sama; mechaniczne bramki, które ją egzekwują, już nie. Korzystaj z tych, które twoje narzędzie ma na pokładzie.

  • Tryb Ask trzyma fazę Architekta — przejrzyj tam plan, zanim przełączysz się na Agent
  • Escape zatrzymuje agenta w trakcie akcji, zachowując kontekst
  • Punkty kontrolne zapisywane są przed każdym zestawem edycji, więc zły krok to przywrócenie stanu, a nie rozplątywanie
  • Panel przeglądu akceptuje lub odrzuca fragment po fragmencie; akceptowanie hurtem to sposób, w jaki przemycane są zmiany spoza planu
  • Cloud Agent (dawniej Background Agent) uruchamia zadanie asynchronicznie, gdy pracujesz nad czymś innym, z przeglądem przed scaleniem

Zaczynaj sesję agenta od kontraktu zakresu powyżej — to pełniejsza wersja jednolinijkowego „wypisz pliki, które zamierzasz zmodyfikować”, która wyłapuje też nowe zależności i usuwanie kodu.

Przeglądanie outputu agenta to nie to samo co przeglądanie pracy człowieka. Agent się nie męczy, nie chodzi na skróty i nie ma gorszych dni — ale ma systematyczne martwe punkty i to tam należy się twoja uwaga.

  1. Sprawdzenie zakresu. Czy zmodyfikował tylko te pliki, które powinien? git diff --stat daje ci kształt zmiany, zanim otworzysz choć jeden plik.
  2. Usunięty kod. Każde usunięcie wymaga uzasadnienia. Usunięcia są najbardziej ryzykowną częścią diffa, bo najłatwiej je przeoczyć — sprawdzanie CSRF z początku tej strony wyszło właśnie w usunięciu.
  3. Bezpieczeństwo. Szukaj zakodowanych na stałe sekretów, brakującej walidacji wejścia, osłabionego uwierzytelniania i niezaescapowanych danych użytkownika. Modele trenowano na dużej ilości kodu, który nie stosuje dobrych praktyk bezpieczeństwa.
  4. Obsługa błędów. Sprawdź, czy błędy są obsługiwane, a nie cicho połykane: puste bloki catch, brakujące sprawdzenia null, zignorowane wartości zwracane.
  5. Pokrycie testami. Czy nowe testy są sensowne, czy przechodzą trywialnie? Sprawdź wyrywkowo, czy test faktycznie nie przechodzi, gdy zepsujesz implementację — testy pisane przez agenta bywają tautologiczne, a zielony zestaw dowodzi przypadków, które ktoś wymyślił, a nie tych, których nie wymyślił.

Dwie różne połówki tej roboty robią dwa prompty. Autoprzegląd poniżej inwentaryzuje zmianę i oflagowuje to, czego agent nie jest pewien; prompt wrogiej recenzji z pętli powyżej atakuje ten sam diff, szukając tego, co poszło źle. Najpierw inwentaryzacja, potem atak — inwentaryzacja mówi ci, gdzie wycelować atak.

Trzecia opcja usuwa konflikt interesów w całości: jedna sesja pisze, a druga, pozbawiona kontekstu, recenzuje. Recenzent nie pamięta, dlaczego skrót wydawał się wtedy rozsądny.

Najbardziej produktywni developerzy korygują wcześnie. Delikatna korekta po pierwszym pliku jest tańsza niż przepisanie po piętnastu i o wiele tańsza niż revert po merge’u.

Stop. The approach you're taking with the notification service
won't work because it doesn't account for our message queue.
Let me redirect: instead of direct database writes, use the
existing event bus in @src/services/eventBus.ts. Read that file
first, then revise your approach.

Jeśli Cursor zaszedł za daleko w złą stronę, cofnij się do ostatniego dobrego punktu kontrolnego, zamiast rozplątywać zmiany ręcznie.

Agent doskonale dopasowuje wzorce i generuje kod. Brakuje mu dokładnie tego, co zapewniają te trzy role:

  • Nie zna twojego kontekstu biznesowego. Nie może wiedzieć, że niewinnie wyglądająca zmiana narusza regułę rozliczeń albo psuje konsumenta downstream.
  • Popełnia pewne siebie, subtelne błędy. Kod w 99% poprawny, z błędem o jeden, warunkiem wyścigu albo brakującym sprawdzeniem autoryzacji, jest groźniejszy niż kod oczywiście zepsuty.
  • Nie potrafi podejmować strategicznych kompromisów. Wydajność kontra czytelność, dowieźć teraz kontra budować pod skalę — to wymaga kogoś, kto bierze na siebie konsekwencje.
  • Stajesz się wąskim gardłem. Jeśli spędzasz więcej czasu na zatwierdzaniu poszczególnych zapisów plików, niż agent na ich generowaniu, nadzorujesz za mocno. Grupuj przegląd: pozwól agentowi skończyć zadanie, a potem przeczytaj cały diff.
  • Przybijanie pieczątki. Gdy agent miał rację dziesięć razy, przestajesz czytać jedenasty — i to ten dowozi buga. Trzymaj w pętli wrogi autoprzegląd i opieraj się na bramkach, które się nie męczą (hooki, CI, wymagani recenzenci).
  • Zmęczenie przy dużych diffach. Diff na 600 linii pokonuje czytanie linijka po linijce. Napraw to u źródła, ograniczając wykonanie do małych kroków, i dziel duże zmiany na commity przeglądane niezależnie.
  • Utrata planu. Długie sesje odpływają. Wklej ponownie ponumerowany plan i zapytaj „na którym kroku jesteśmy i co zmieniło się względem planu?”, zanim ruszysz dalej. Jeśli korekty przestają działać, problemem jest zwykle przeciążenie kontekstu, a nie sformułowanie promptu — odwołuj się jawnie do pliku planu i trzymaj sesje przy jednym zadaniu.
  • Bugi z kodu AI docierające na produkcję. To sygnał, żeby uszczelnić proces, a nie czytać uważniej: dodaj obowiązkowe progi pokrycia testami i przenieś rutynowy przegląd na wzorzec pisarz/recenzent z dwoma oddzielnymi sesjami.

Dokąd pójść dalej z przeglądem z człowiekiem w pętli

Dział zatytułowany „Dokąd pójść dalej z przeglądem z człowiekiem w pętli”