W pierwszym artykule z tej serii wyjaśniliśmy, jak przygotować komputer do vibe coding. Zainstalowaliśmy Linux, skonfigurowaliśmy Codex i Antigravity, połączyliśmy GitHub i opublikowaliśmy pierwszą aplikację za pomocą Railway.
Udało nam się stworzyć niewielką aplikację przy użyciu sztucznej inteligencji bez samodzielnego pisania kodu.
Ale to była próba. Poprosiliśmy Codex o napisanie programu, sprawdziliśmy, czy działa, a następnie użyliśmy Antigravity do oceny rezultatu. Na początek wystarczy, lecz jeśli chcemy pracować nad prawdziwymi projektami, potrzebujemy lepszej organizacji.
Co się dzieje, gdy mamy kilka funkcji do zrobienia? Jak zapobiec modyfikowaniu przez AI plików, których nie powinna dotykać? Kto sprawdza, czy rozwiązanie zostało dobrze zaplanowane, zanim zaczniemy programować? I skąd wiemy, że opublikowaliśmy dokładnie to, co sprawdziliśmy?
Aby odpowiedzieć na te pytania, stopniowo opracowałem własną metodę pracy. Nie wymyśliłem nic rewolucyjnego: dostosowałem typowe praktyki profesjonalnego tworzenia oprogramowania do środowiska, w którym znaczną część pracy wykonują agenci sztucznej inteligencji.
Wyjaśnię ci krok po kroku, jak to zorganizować i stosować. Może pomoże ci to odtworzyć mój sposób pracy.
Jak organizuję pracę z agentami AI
Pomysł jest prosty: jedna sztuczna inteligencja tworzy oprogramowanie, a druga kontroluje jej pracę, podczas gdy my zachowujemy kontrolę nad najważniejszymi decyzjami.
Sam korzystam z pięciu podstawowych narzędzi:
| Narzędzie | Funkcja |
| Codex | Analizuje, planuje, programuje, testuje i dokumentuje. |
| Antigravity | Niezależnie audytuje plan i kod. |
| GitHub | Przechowuje kod, wersje i Pull Requests. |
| Linear | Organizuje zadania, testy, audyty i statusy. |
| Notion | Przechowuje wymagania, decyzje i historię projektu. |
Do tego dodaję jeszcze dwa: Local WP w przypadku projektów opartych na WordPress oraz Convex lub Supabase, jeśli aplikacja internetowa potrzebuje bazy danych.
Notion jest opcjonalny, choć polecam go przy średnich projektach. Za chwilę wyjaśnię dlaczego.
Nie musimy też korzystać dokładnie z tych aplikacji. Możemy na przykład zastąpić Codex przez Claude Code albo powierzyć audyt innemu agentowi. Najważniejsze to oddzielić zakresy odpowiedzialności.
Cały proces wygląda tak:
- Wymagania.
- Plan techniczny.
- Pierwszy audyt.
- Tworzenie i testowanie.
- Drugi audyt.
- GitHub.
- Wdrożenie.
- Weryfikacja.
Kroki 2 (Codex) i 3 (Antigravity) można powtarzać wielokrotnie: jeśli Antigravity znajdzie problem, Codex go naprawia, a my ponawiamy kontrolę. Chodzi o pracę w cyklach tworzenia i sprawdzania, bez przechodzenia do kolejnego etapu, dopóki nie rozwiążemy istotnych problemów.
W mojej metodzie obowiązkowe są dwa audyty, choć ich szczegółowość zależy od złożoności projektu. Pierwszy sprawdza to, co zamierzamy zrobić, a drugi to, co faktycznie zrobiliśmy.
I jeszcze ważna rzecz: GO od audytora nie oznacza zgody na publikację. Ta decyzja nadal należy do nas.
Krok 1. Przygotowanie środowiska pracy z Codex
Zaczynamy od komputera skonfigurowanego w pierwszym poradniku. Codex, Antigravity i GitHub już działają, więc nie będziemy powtarzać instalacji.
Otwieramy terminal w folderze projektu i uruchamiamy Codex:
cd ~/Proyectos/mi-proyecto
codex
Teraz jedna z rzeczy, które najbardziej lubię w pracy z agentami: nie musimy ręcznie konfigurować całej struktury projektu. Możemy poprosić o to Codex.
Prompt 1. Konfiguracja środowiska pracy
Chcę przygotować ten projekt do pracy w ramach procesu tworzenia oprogramowania nadzorowanego przez AI.
Będziesz analitykiem i programistą. Antigravity będzie niezależnym audytorem. Użyjemy GitHub do kodu, Linear do zadań i opcjonalnie Notion do dokumentacji.
Przeanalizuj projekt i sprawdź dostępne połączenia. Zaproponuj stałe instrukcje, minimalną dokumentację, zasady uprawnień i proces z dwoma obowiązkowymi audytami: planu technicznego oraz kodu.
Implementacje, ważne operacje Git i wdrożenia wymagają zgody człowieka. Zadania zamykamy dopiero po weryfikacji na produkcji.
Najpierw przedstaw plan konfiguracji. Nie twórz plików ani nie modyfikuj usług bez uzyskania zgody.
Codex powinien przeanalizować dostępne zasoby i wskazać, czego brakuje.
Zwykle pewne czynności będziemy musieli wykonać osobiście:
- Zalogować się do Linear lub Notion.
- Zatwierdzić integrację.
- Zaakceptować uprawnienia lub utworzyć połączenie wymagające uwierzytelnienia w przeglądarce.
BARDZO WAŻNE: nie wolno przekazywać haseł ani tokenów przez wklejanie ich bezpośrednio do czatu.
Skorzystamy z mechanizmów uwierzytelniania poszczególnych usług (Github i Claudflare je mają) i nadamy tylko niezbędne uprawnienia.
Po zatwierdzeniu konfiguracji Codex może przygotować pliki i uporządkować narzędzia.
Oczywiście sprawdzimy, czy rzeczywiście to zrobił, więc poprosimy go o weryfikację. Agent nie może utworzyć połączenia z Linear, jeśli w jego środowisku brakuje odpowiedniej integracji.
Krok 2. Organizacja dokumentacji bez zaśmiecania repozytorium plikami
Do pracy z agentami potrzebujemy czegoś, czego same rozmowy nam nie zapewnią: pamięci operacyjnej projektu.
Wyobraź sobie, że od kilku tygodni pracujemy nad projektem i rozpoczynamy nową sesję Codex. Nie chcemy ponownie wyjaśniać całej architektury, używanych narzędzi, plików, które można modyfikować, ani sposobu wdrażania.
Aby tego uniknąć, użyjemy dwóch podstawowych dokumentów w repozytorium:
- AGENTS.md: stałe instrukcje dla Codex, granice jego działania i zasady tworzenia oprogramowania.
- PROJECT.md: opis projektu, podstawowa architektura, środowiska i odnośniki do dokumentacji.
Codex może utworzyć je na podstawie naszych wymagań.
A po co nam Notion?
W małych projektach pliki Markdown mogą wystarczyć do dokumentowania zmian i decyzji. Kiedy jednak przybywa funkcji, decyzji, wymagań i zmian architektury, w repozytorium zaczyna gromadzić się zbyt wiele dokumentów.
Dlatego polecam Notion do średnich projektów.
Tam będziemy przede wszystkim przechowywać PRD (Product Requirements Document), decyzje techniczne i historię projektu. Linear będzie zawierać zadania, ich statusy, audyty i testy. GitHub zachowa kod.
Co ciekawe, z Notion i Linear korzystać będą przede wszystkim sami agenci. Codex będzie pisał i aktualizował dokumentację, sprawdzał wymagania przed programowaniem oraz zapisywał wyniki. Antigravity będzie potrzebować tych informacji do audytu.
Nie będziemy musieli własnoręcznie pisać całych stron dokumentacji. Naszym zadaniem będzie sprawdzenie, czy wymagania i najważniejsze decyzje odpowiadają temu, czego chcemy.
Krok 3. Określenie tego, co chcemy zbudować
Posłużymy się przykładem rzeczywistej funkcji, którą opracowałem dla tej strony.
W moim magazynie strony tagów wyświetlały wpisy w porządku chronologicznym. Chciałem je poprawić tak, aby wyróżniały najciekawsze treści bez utraty zwykłej listy.
Taką potrzebę możemy opisać Codex zwykłym językiem, wiedząc, że taka prośba pozostawia sporo otwartych pytań.
- Ile artykułów wyróżniamy?
- Jak wybieramy te istotne?
- Co dzieje się z pozostałymi?
- Czy ma działać na wszystkich stronach?
- Których elementów nie chcemy zmieniać?
Zanim zaczniemy analizę, warto na nie odpowiedzieć.
Prompt 2. Przygotowanie wymagań i planu technicznego
Chcę stworzyć tę funkcjonalność: [OPIS].
Przeczytaj instrukcje i dokumentację projektu. Przekształć potrzebę w weryfikowalne wymagania i kryteria akceptacji. Przygotuj lub zaktualizuj PRD i zorganizuj niezbędne zadania w Linear.
Sprawdź istniejący kod i zaproponuj najprostsze rozwiązanie spełniające wymagania, wskazując objęte zmianami pliki, ryzyka, alternatywy i testy.
Jeszcze nie programuj. Zapytaj mnie o decyzje funkcjonalne, których nie da się podjąć na podstawie dostępnych informacji, i przygotuj plan do niezależnego audytu.
To jedna z najważniejszych zmian w porównaniu ze zwykłym poproszeniem AI o napisanie programu.
Codex może nam pomóc przekształcić pomysł w specyfikację. My decydujemy, czy ta specyfikacja odzwierciedla naszą potrzebę.
Na przykład w przypadku tagów kryterium akceptacji nie mogło ograniczać się do wyświetlenia wyróżnionych artykułów. Musieliśmy też zachować nawigację, uniknąć niepożądanych duplikatów i zapewnić poprawne działanie na poszczególnych stronach.
Po zatwierdzeniu założeń Codex je zapisuje i przygotowuje plan techniczny.
Nadal nie napisaliśmy ani jednej linijki kodu.
Projekt interfejsu
W tym przypadku dokładnie wiedziałem, jakiego projektu graficznego chcę, więc nie prosiłem o propozycje wizualne. Jednak w innych sytuacjach poprosiłbym o nie właśnie na tym etapie, aby agent uwzględnił je przed zaproponowaniem rozwiązania technicznego.
Oczywiście jeśli wiesz, czego chcesz, po prostu mu to wyjaśniasz. A jeśli potrzebujesz funkcji dotyczącej backendu, a nie frontendu, makiety też nie będą konieczne.
Krok 4. Pierwszy audyt: sprawdzenie planu za pomocą Antigravity
Teraz do akcji wkracza nasz drugi agent.
Otwieramy drugi terminal w tym samym folderze projektu i uruchamiamy:
agy
W moim obecnym procesie Antigravity działa ręcznie. Nie pozwalamy, aby Codex wywoływał go automatycznie i kontynuował bez naszej oceny wyniku.
Chcemy, aby działał jako niezależny audytor, a nie kolejny programista, który zaczyna zmieniać pliki.
Prompt 3. Audyt planu technicznego
Działaj wyłącznie jako niezależny audytor techniczny.
Sprawdź instrukcje projektu, wymagania i plan zaproponowany przez Codex. Oceń, czy rozwiązanie jest wykonalne, wystarczająco proste, bezpieczne i zgodne z dotychczasowym działaniem systemu.
Sprawdź ryzyka, możliwe regresje i adekwatność zaplanowanych testów.
Wydaj uzasadnioną opinię: GO, warunkowe GO lub NO-GO. Wyraźnie zaznacz, jeśli nie masz wystarczających dowodów.
Wskaż konkretne problemy i konieczne poprawki. Nie zmieniaj żadnych plików.
Dlaczego przeprowadzać audyt przed programowaniem?
Bo rozwiązanie może być zaprogramowane bezbłędnie, a mimo to być złym rozwiązaniem.
Być może wprowadza niepotrzebną zależność, powiela istniejące dane, wykonuje zbyt wiele zapytań lub utrudnia przyszłe utrzymanie.
Na przykład przy tagach nie wystarczyło uzyskać systemu wyróżnionych artykułów. Trzeba było także przemyśleć obliczanie ich kolejności bez wykonywania powolnych operacji przy każdym wejściu na stronę.
Jeśli audytor wykryje problemy, przekazujemy raport do Codex. Agent poprawia plan, a my ponawiamy audyt, gdy jest to konieczne.
Nie zaczynamy programowania, dopóki nie mamy zaakceptowanego planu i ludzkiej zgody na jego realizację.
Krok 5. Codex tworzy funkcję i przeprowadza testy
Po zatwierdzeniu planu rozpoczynamy implementację.
Codex będzie pracować na osobnej gałęzi repozytorium. Jeśli czytałeś pierwszą część, znasz już Git i GitHub, więc nie musimy powtarzać sposobu ich użycia.
Nowość polega na tym, że nie programujemy bezpośrednio na stabilnej wersji projektu. Przygotowujemy zmiany osobno, aby móc je sprawdzić przed scaleniem.
Prompt 4. Implementacja funkcji
Zezwalam na wdrożenie zatwierdzonego i zaudytowanego planu dotyczącego [ZADANIA W LINEAR].
Pracuj na osobnej gałęzi i ogranicz zmiany do zatwierdzonego zakresu.
Zaimplementuj rozwiązanie, przeprowadź odpowiednie testy i sprawdź możliwe regresje. Udokumentuj wyniki w Linear.
Przygotuj pełny diff, wskaż zmodyfikowane pliki i dostarcz dowody potrzebne do drugiego audytu.
Nie wykonuj merge ani wdrożenia. Zatrzymaj się, gdy implementacja będzie gotowa do przeglądu.
Codex może modyfikować pliki, wykonywać testy i poprawiać błędy w zatwierdzonym przez nas zakresie.
Musimy jednak uważać na jedną rzecz: zapewnienie AI, że funkcja działa, nie oznacza, że zostało to sprawdzone.
Potrzebujemy dowodów. Zależnie od projektu mogą to być testy automatyczne, wyniki uruchomienia, kontrole funkcjonalne lub ich połączenie.
Musimy również odróżniać to, co Codex rzeczywiście przetestował, od tego, czego jeszcze nie może zweryfikować.
Wracając do przykładu: nie wystarczy sprawdzić, czy wyświetlają się trzy wyróżnione artykuły. Musimy zobaczyć, co się dzieje, kiedy dostępnych jest mniej artykułów, użytkownik przechodzi na kolejną stronę albo jakiejś treści brakuje oczekiwanych danych, np. artykuł nie został przetłumaczony na jeden z języków.
Agent powinien zapisać te kontrole oraz wszelkie ograniczenia.
Krok 6. Drugi audyt: przegląd rzeczywistego kodu
Funkcja została zaimplementowana, ale jeszcze jej nie publikujemy.
Wracamy do Antigravity i prosimy o sprawdzenie zmodyfikowanego kodu, a nie tylko raportu przygotowanego przez Codex.
Prompt 5. Audyt implementacji
Działaj jako niezależny audytor techniczny [ZADANIA W LINEAR].
Przejrzyj cały diff, zatwierdzony plan, wymagania i dowody z testów.
Szukaj błędów funkcjonalnych, problemów bezpieczeństwa, regresji, niepotrzebnej złożoności i zmian wykraczających poza zatwierdzony zakres.
Wydaj uzasadnioną opinię i w miarę możliwości wskaż znaleziska według pliku i lokalizacji.
Zapisz skrót SHA-256 audytowanego diffu, aby można było jednoznacznie zidentyfikować sprawdzoną wersję.
Nie zmieniaj plików ani nie zatwierdzaj commitów, merge ani wdrożeń.
Istotne są dwie kwestie.
Po pierwsze, Antigravity musi mieć dostęp do tych samych zasad i wymagań, których używał Codex. W przeciwnym razie może ocenić jako poprawne technicznie rozwiązanie, które nie spełnia naszych oczekiwań.
Po drugie, należy zachować dokumentację całego zestawu sprawdzonych zmian. Pozwala to ustalić dokładną wersję, która otrzymała GO, i wykryć, czy kod zmienił się później. Skrót musi być obliczany w powtarzalny sposób na tej samej zawartości.
U mnie zapisujemy wszystko w Linear, przy odpowiednim zadaniu.
Jeśli Antigravity znajdzie błędy, wracamy do Codex, prosimy o poprawki i powtarzamy audyt.
Dwaj agenci mogą się mylić, nawet jeśli wydają zgodną ocenę. Dlatego audyty to dodatkowe kontrole, a nie absolutne gwarancje. Dlatego też opcjonalnie możemy dodać trzeci.
Krok 7. Integracja zmian w GitHub
Kiedy audyt zakończy się GO, możemy przygotować integrację. Typowy przebieg to:
Branch > Commit > Push > Pull Request > Merge.
Nie musimy wykonywać tych poleceń ręcznie. Codex może się tym zająć, ale musimy rozumieć, na co wyrażamy zgodę.
Pull Request pozwala nam sprawdzić, jakie zmiany chcemy włączyć do głównej gałęzi, z jakimi testami i zaleceniami audytora.
Warto też sprawdzić, czy wersja przeznaczona do scalenia jest nadal tą samą, którą zaudytowano. Jeśli zmienimy kod po otrzymaniu GO, ocena może przestać obowiązywać.
Wolę wymagać wyraźnej zgody na ważne operacje. Niektóre można połączyć przy ściśle określonym zakresie, ale nie należy dawać nieograniczonej swobody scalania i publikowania.
Czym innym jest pozytywna ocena audytora, a czym innym nasza decyzja o włączeniu zmian.
W tym momencie mogłaby się pojawić trzecia AI: możemy wprowadzić drugiego wyspecjalizowanego audytora, np. CodeRabbit.
W przeciwieństwie do Antigravity, którego używamy do lokalnej kontroli planu i kodu, CodeRabbit może automatycznie analizować Pull Requests w GitHub przed scaleniem.
To interesująca dodatkowa kontrola dla ważnych projektów, choć nie jest konieczna i kosztuje, mimo że niewiele w stosunku do wartości, jaką wnosi. Na razie wolę pozostać przy dwóch ręcznych audytach i rozważyć trzeci, gdy projekt się rozrośnie.
Krok 8. Wdrożenie i sprawdzenie działania w środowisku produkcyjnym
Ten krok zależy w dużej mierze od tego, gdzie hostujemy projekt.
W pierwszej części użyliśmy Railway. Moglibyśmy też publikować przez GitHub Actions, narzędzia naszego hostingu lub dowolny inny system wdrożeniowy.
Szczegóły dotyczące WordPress, LocalWP i Webempresa omówimy w innym artykule.
Tutaj interesuje nas ogólna zasada: poprawnie zakończone wdrożenie nie oznacza, że funkcja działa prawidłowo.
Po opublikowaniu zmiany musimy sprawdzić rzeczywistą aplikację.
W naszym przykładzie oznacza to odwiedzenie publicznych stron, sprawdzenie wyróżnionych artykułów, nawigacji po liście i upewnienie się, że nie naruszyliśmy innych funkcji.
Musimy też potwierdzić, że wyświetlana jest nowa wersja. Czasem kod zostaje poprawnie opublikowany, ale pamięć podręczna nadal podaje starszą zawartość, co przydarzyło mi się z WP Rocket.
Przy ważnych projektach powinniśmy mieć plan przywrócenia stabilnej wersji, jeśli coś pójdzie nie tak.
Dopiero po tych kontrolach możemy uznać funkcję za ukończoną.
Krok 9. Zamknięcie zadania i przygotowanie kolejnego etapu
Po weryfikacji wyniku prosimy Codex o aktualizację Linear i dokumentacji projektu.
Powinien zapisać, co zostało opracowane, która wersja jest opublikowana, jakie testy wykonaliśmy i czy pozostały otwarte problemy.
Zadanie zostaje oznaczone jako ukończone dopiero po weryfikacji na produkcji, a nie kiedy Codex skończy programować lub Antigravity wyda GO.
Ta dokumentacja ma jeszcze jedną zaletę: możemy zakończyć sesję i rozpocząć nową bez utraty kontekstu.
Właściwie zalecam to, kiedy rozpoczynamy inną funkcjonalność. Agenci mogą odtworzyć zasady, wymagania i decyzje z dokumentacji projektu zamiast polegać na niekończących się rozmowach.
Z czasem możemy zautomatyzować część koordynacji między Codex a Antigravity, ale na razie wolę robić to ręcznie, sprawdzać skuteczność procedury i zyskać do niej zaufanie, zanim zrezygnuję z nadzoru.
Czy warto tak pracować przy każdym projekcie?
Nie.
Przy tworzeniu prostego prototypu czy dwudziestominutowym eksperymencie dokumentacja, dwa audyty i proces publikacji to przesada.
Ale kiedy tworzymy prawdziwą stronę, aplikację dla klienta lub projekt, który będziemy utrzymywać przez miesiące, taki dodatkowy wysiłek ma pełny sens.
Zaletą tego procesu nie jest wyeliminowanie błędów ani zastąpienie wiedzy programistycznej, lecz bardziej uporządkowana praca, zachowywanie decyzji i wykrywanie problemów, zanim dotrą do użytkowników. Minimalizujemy błędy charakterystyczne dla początkowego vibe coding.
A ponieważ większość działań operacyjnych wykonują agenci, możemy skupić się na tym, co ważne: decydowaniu, czego chcemy, zatwierdzaniu sposobu realizacji i sprawdzaniu, czy wynik działa.
Podsumowanie
W pierwszym artykule przygotowaliśmy komputer. W tym przygotowaliśmy nasz sposób pracy.
Teraz wiemy, jak:
- Przekształcić potrzebę w wymagania.
- Poprosić Codex o plan.
- Przeprowadzić audyt z Antigravity.
- Opracować funkcję.
- Sprawdzić kod.
- Opublikować go z kontrolą wersji.
- Wszystko udokumentować.
Nie chodzi po prostu o szybsze programowanie z AI, lecz o to, by móc utrzymywać to, co tworzymy, rozumieć wprowadzone zmiany i mieć proces naprawiania problemów, kiedy się pojawią.
W kolejnym artykule zastosujemy tę metodę w WordPress: lokalny rozwój, testy, pliki objęte kontrolą wersji i wdrożenie na prawdziwym hostingu.
Najczęstsze pytania
Czy muszę umieć programować, aby korzystać z tej metody?
Nie musisz samodzielnie pisać kodu, ale powinieneś rozumieć podstawy tworzenia oprogramowania i nauczyć się interpretować testy oraz ryzyka. AI nie zdejmuje z nas odpowiedzialności za wynik.
Czy muszę korzystać z Codex i Antigravity?
Nie. Możesz zastąpić je innymi agentami do programowania i przeglądu. Najważniejsze jest rozdzielenie ról i unikanie sytuacji, w której programista sam ocenia całą swoją pracę.
Czy potrzebuję Notion i Linear?
Linear to narzędzie do zadań używane w tym poradniku. Notion jest opcjonalny przy prostych projektach, ale polecam go, gdy przybywa wymagań, decyzji i dokumentacji. Alternatywnie można przechowywać te informacje w Markdown.
Co zrobić, gdy Antigravity wyda NO-GO?
Przekaż raport do Codex, poproś o poprawienie problemów i powtórz audyt. Nie przechodź automatycznie do kolejnego etapu.
Dlaczego przeprowadzać dwa audyty?
Ponieważ pierwszy wykrywa problemy w założeniach, a drugi sprawdza implementację. Kontrola samego kodu może przeoczyć błędy projektowe, które łatwiej byłoby naprawić wcześniej.
Czy mogę stosować tę metodę z WordPress lub innymi technologiami?
Tak. Proces jest niezależny od języka i platformy. Zmieniają się tylko testy, środowiska i sposoby publikacji.
Kiedy zadanie jest naprawdę ukończone?
Gdy zatwierdzona wersja została opublikowana, jej działanie sprawdzono w produkcji, a dowody i decyzje udokumentowano.

Dodaj komentarz