# Code review PR-a agenta bez czytania każdej linii

URL: https://developertoolkit.ai/pl/workflows/ship/agent-pr-review/
Description: Sześć kroków oceny PR-a agenta: zmiana specyfikacji, dowody, flagi ryzyka, zmiany wyroczni, próbka hotspotów, a potem akceptacja, zwrot albo eskalacja.

Code review pull requesta agenta bez czytania każdej linii to sześciokrokowa ocena: sprawdzenie zmiany specyfikacji, potwierdzenie dowodów, przegląd flag ryzyka, lektura każdej zmiany wyroczni, próbka kilku hotspotów, a na końcu akceptacja, zwrot albo eskalacja. Agent recenzujący najpierw przechodzi mechaniczną checklistę, a wskazany człowiek czyta kod tylko w klasach eskalacji.

Wtorek rano, czeka na ciebie dziewięć pull requestów agentów. Pierwszy ma 640 linii w 14 plikach, wszystkie sprawdzenia są zielone, a opis brzmi „Zaimplementowano paginację zgodnie z prośbą”. Możesz spędzić nad nim cały ranek albo przejrzeć go pobieżnie i liczyć na szczęście. Ta strona daje trzecią drogę: około 15 minut na pull request i ślad, którego możesz bronić.

## Co zyskujesz dzięki ocenie PR-ów agenta

- **Sześciokrokowy protokół oceny** z budżetem czasu i warunkiem zatrzymania dla każdego kroku.
- **Checklistę dla agenta recenzującego**, którą commitujesz do repozytorium: dawną 50-punktową checklistę dla człowieka, przepisaną na sprawdzenia, które agent wykonuje i dokumentuje dowodami.
- **Listę eskalacji do człowieka**: klasy zmian, w których ktoś wciąż czyta kod, i pytanie, na które ta osoba odpowiada.
- **Trzy werdykty** (akceptacja, zwrot, eskalacja) z kryteriami, dzięki którym dwóch recenzentów dochodzi do tej samej decyzji.
- **Mapę warstw wokół review wykonywanego przez człowieka**, z zespołem Claude Code w Anthropic jako jednym datowanym przykładem, oraz regułę, że każde znalezisko dostaje odpowiedź.
- **Szablon pull requesta** z polami Testing, Risk i How to revert oraz **limity rund**, które nie pozwalają agentowi-autorowi i agentowi recenzującemu zapętlić się.
- **Cztery prompty do skopiowania** i konfigurację dla Claude Code, Codeksa i Cursora.
- **Cztery miary**, które pokazują, czy sama ocena działa.

Ta strona wprowadza w praktykę [czytanie dowodów zamiast kodu](/pl/ladder/evidence-not-diffs/); zacznij od tamtej strony, jeśli zatwierdzanie nieprzeczytanego kodu to dla ciebie wciąż nowy pomysł.

## Dlaczego 50-punktowa checklista dla człowieka przestała działać

Dawną odpowiedzią była 50-punktowa checklista stosowana przez człowieka czytającego diff. Punkty były trafne; problemem był czytelnik.

Pull requesty jednocześnie urosły i dłużej czekają na review. DX zmierzył, że mediana rozmiaru pull requesta wzrosła z 44 do 72 linii między lipcem 2025 a czerwcem 2026 (DX, Justin Reock, 17 czerwca 2026). Raport *Acceleration Whiplash* firmy Faros AI (kwiecień 2026, telemetria z 22 000 programistów) pokazał wzrost mediany czasu w review o 441,5% i o 31,3% więcej pull requestów scalanych bez żadnego review. Checklista zależna od czytania każdej linii kończy się na dwa sposoby: kolejka staje albo czytanie po cichu zanika.

Rozwiązanie zachowuje każdy punkt i przenosi go gdzie indziej: agent wykonuje mechaniczne sprawdzenia i dołącza dowody, a człowiek czyta raport, zmiany wyroczni i krótką próbkę kodu, a potem decyduje. To przejście z [poziomu 3, na którym przeglądasz diffy](/pl/ladder/level-3-review-diffs/), na [poziom 4, na którym piszesz specyfikacje](/pl/ladder/level-4-write-specs/) i oceniasz dowody.

## Jak działa sześciokrokowa ocena?

Wykonuj kroki po kolei. Każdy może wcześniej zakończyć review, więc drogie kroki wykonujesz tylko na pull requestach, które przeszły tanie.

| Krok | Pytanie | Na co patrzysz | Budżet | Kończy review, gdy |
| ---- | ------- | -------------- | ------ | ------------------ |
| 1. Zmiana specyfikacji | Czy agent zmienił to, o co prosiliśmy, i tylko to? | Ticket i lista zmian zachowania prostym językiem | 2 min | Zmiana zachowania, o którą nikt nie prosił, albo brak specyfikacji → zwrot |
| 2. Dowody | Czy każde kryterium akceptacji ma sprawdzenie wykonane na tym commicie? | Mapowanie kryteriów, wyniki testów, zrzuty ekranu lub trace'y z działania | 3 min | Kryterium oznaczone `UNVERIFIED` albo wyniki ze starszego commita → zwrot |
| 3. Flagi ryzyka | Czy zmiana dotyka klasy eskalacji albo czy agent recenzujący zgłosił bloker? | Raport agenta recenzującego i lista zmienionych ścieżek | 1 min | Klasa eskalacji → eskalacja; znalezisko P0 lub P1 → zwrot |
| 4. Zmiany wyroczni | Czy zmiana zmieniła znaczenie „zielonego”? | Diff testów, fixture'ów, snapshotów, CI, lintera i konfiguracji typów | 3 min | Sprawdzenie poluzowane bez uzasadnienia w specyfikacji → zwrot |
| 5. Próbka hotspotów | Czy kod, którego nie czytałem, ukrywa coś, czego nie wychwyciły dowody? | Do trzech fragmentów diffa, wybranych według reguły, zanim na nie spojrzysz | 5 min | Realny problem → zwrot i dopisanie brakującego sprawdzenia |
| 6. Decyzja | Akceptacja, zwrot czy eskalacja? | Twoje notatki z kroków 1–5 | 1 min | — |

Budżet 15 minut to nasza wyjściowa zasada, nie wynik badań. Jeśli pull requesta nie da się ocenić w tym czasie, to też jest informacja: jest za duży, ma słabe dowody albo należy do klasy eskalacji.

1. **Porównaj zmianę specyfikacji z ticketem.** Pull request mówi w zdaniach, które zachowanie się zmieniło: „`GET /orders` zwraca 50 pozycji na stronę i `next_cursor`; stary parametr `page` zwraca 400”. Porównaj to z tym, o co prosił ticket. Rozrost zakresu, źle zrozumiane wymaganie i cicha zmiana kontraktu wychodzą tu bez otwierania pliku. Jeśli agent nie potrafi w kilku zdaniach wyjaśnić architektury, którą zmienił, zwróć pull request.

2. **Potwierdź dowody, linia po linii.** Każde kryterium akceptacji potrzebuje jednej linii: kryterium, sprawdzenie, które je dowodzi, i wynik, na przykład `old page param returns 400 → orders.contract.test.ts:88 → pass`. Upewnij się, że wyniki dotyczą ostatniego commita, a nie wcześniejszego pusha. Przy zmianach wizualnych lub operacyjnych szukaj zrzutu ekranu albo trace'a dla każdej ścieżki akceptacji, łącznie z nazwanymi przypadkami błędów. Format tego manifestu jest zdefiniowany w jednym miejscu: w [pakiecie dowodów](/pl/workflows/ship/evidence-bundle/).

3. **Przejrzyj flagi ryzyka.** Raport agenta recenzującego wymienia dotknięte klasy eskalacji i znaleziska według wagi. Klasa eskalacji kieruje pull request do wskazanej osoby, która czyta kod; znalezisko P0 lub P1 odsyła go agentowi-autorowi.

4. **Przeczytaj w całości każdą zmianę wyroczni.** To jedyna część diffa, którą czytasz zawsze. Zmiana testu, fixture'a, snapshotu, kroku CI, reguły lintera albo `tsconfig` zmienia znaczenie każdego innego sprawdzenia: asercja poluzowana z dokładnej wartości do „truthy”, pominięty test albo wygenerowany od nowa snapshot mogą przepuścić błędną implementację. Jeśli testy są nowe, zapytaj, czy nie przeszłyby po usunięciu funkcji; mechaniczną odpowiedź, testy mutacyjne, opisuje strona o tym, [jak silna jest twoja wyrocznia](/pl/workflows/test/oracle-strength/).

5. **Przeczytaj próbkę hotspotów wybraną, zanim spojrzysz na kod.** Wybierz do trzech fragmentów diffa. Pierwsze dwa wybierasz według reguły, w tej kolejności: fragment, który agent recenzujący oznaczył poniżej swojego progu pewności; obsługa błędów wokół wywołań zewnętrznych, ponowień i timeoutów; współbieżność albo przejścia stanów; nowa zależność albo nowa abstrakcja; fragment, którego nie wyjaśnia żadne zdanie zmiany specyfikacji; największy fragment poza testami. Trzeci wybierasz losowo (losowy zmieniony plik, a w nim największy fragment), żeby nic w samym pull requeście nie decydowało o tym, co zostanie przeczytane. Te fragmenty czytasz porządnie.

6. **Zdecyduj i zapisz werdykt w pull requeście.** Skorzystaj z tabeli werdyktów poniżej i zapisz, które fragmenty przeczytałeś, żeby ślad zaufania pokazywał, co człowiek czytał.

Losowy plik wybieraj poleceniem, a nie na oko, a potem przeczytaj jego największy fragment:

```bash
# Terminal, on the pull request branch
git diff --name-only main...HEAD -- . ':!*.test.*' ':!*.spec.*' ':!**/__snapshots__/**' | sort -R | head -n 1
```

## Akceptacja, zwrot czy eskalacja: który werdykt pasuje?

Zapisz werdykt i jego uzasadnienie w komentarzu do pull requesta; „LGTM” nie jest uzasadnieniem.

| Werdykt | Kryteria (wszystkie muszą być spełnione) | Kto działa dalej |
| ------- | ---------------------------------------- | ---------------- |
| **Akceptacja** | Zmiana specyfikacji zgadza się z ticketem; każde kryterium ma zaliczone sprawdzenie na ostatnim commicie; żadna zmiana wyroczni nie luzuje sprawdzenia; żadna klasa eskalacji nie jest dotknięta; próbka nie wywołała pytania, na które nie odpowiadają dowody | Ty scalasz albo rusza auto-merge; produkcję pilnuje progressive delivery |
| **Zwrot** | Którekolwiek z: zmiana zachowania, o którą nikt nie prosił, kryterium `UNVERIFIED`, nieaktualne wyniki, poluzowane sprawdzenie, znalezisko P0 lub P1, problem w przeczytanym fragmencie albo pull request ponad budżet rozmiaru zespołu | Agent-autor, z niespełnionymi punktami jako następnym promptem. Maksymalnie dwie rundy, potem przejmuje człowiek |
| **Eskalacja** | Którekolwiek z: dotknięta klasa eskalacji; agent recenzujący i dowody się nie zgadzają; agent nie mógł wykonać sprawdzenia, na które się powołuje; zmiana podejmuje decyzję projektową, której specyfikacja nie rozstrzygnęła | Wskazana osoba czytająca kod w tej klasie, przez `CODEOWNERS` |

Limit dwóch zwrotów pochodzi z praktyki. W Stripe agenci Minions mają limit najwyżej dwóch rund CI („at most two rounds of CI”) i tworzą ponad 1300 scalanych co tydzień pull requestów (blog inżynierski Stripe, Alistair Gray, Minions części 1 i 2, 9 i 19 lutego 2026). To dane wewnętrzne jednej firmy, nie benchmark. Pull request, który po dwóch zwrotach wciąż nie przechodzi, ma problem ze specyfikacją, a nie z kodem. [Ograniczona pętla review i poprawek](/pl/developer-scorecard-guide/auto-pr-workflow/) pokazuje, jak zautomatyzować ścieżkę zwrotu z tym warunkiem zatrzymania.

Gdy przeczytany fragment ujawni realny problem, napisz też sprawdzenie, które by go wychwyciło, żeby następny pull request z tą samą wadą nie przeszedł, zanim ktokolwiek zajrzy do próbki.

## Checklista dla agenta recenzującego

Poniższa checklista to dawna 50-punktowa checklista dla człowieka, zachowana punkt po punkcie i przepisana tak, że każdy punkt wymaga od agenta **dowodu** (polecenia i jego kodu wyjścia, `file:line`, wyniku wyszukiwania), a nie opinii. Zacommituj ją jako `.github/review/agent-checklist.md` i ustaw tech leada jako jej code ownera, żeby standard review zmieniał się tylko przez pull request, który przeszedł review. Checklista zostaje po angielsku, bo to prompt.

```markdown title=".github/review/agent-checklist.md"
# Review-agent checklist

Review the changes on this branch against main. Do not edit any file.
Run checks; never infer their results. Report only what could matter in
production. No style comments unless the style hides a bug.

Mark every item PASS, FAIL or N/A with one line of evidence: a command and its
exit status, a file:line, or a search result. For every FAIL give severity
(P0 blocks merge, P1 fix before merge, P2 fix soon, P3 optional), file:line,
why it matters in production, and the smallest safe fix.

## 1. Scope and intent
- Link the ticket or spec. If there is none, FAIL and stop.
- List every behaviour change as a sentence. Flag any the ticket did not ask for.
- List files the change did not need, and any refactor mixed into feature work.
- List what the change intentionally does not do, and every assumption made.
- Explain in three sentences the architecture this change touches. If you cannot, FAIL.
- Check names, copy, comments and examples against the product's domain terms.

## 2. Context fit
- For each new piece, name the existing local pattern it follows (file:line).
  FAIL a new architecture where a local pattern exists.
- Search for an existing utility, type, hook, component or service this duplicates.
- For each new abstraction, show the current call sites it deduplicates.
- Check public interfaces stay backward-compatible unless the PR declares a break.
- Check naming, error handling, logging, telemetry and analytics against the
  surrounding module and its existing helpers.
- Check module boundaries and the CODEOWNERS owner of every touched path.

## 3. Correctness
- Per changed function, list which of these a test covers: empty input,
  null/undefined, limits, duplicates, timeouts. Name the missing ones.
- For each external call, state what happens on partial failure.
- Find un-awaited async work, and fire-and-forget work without lifecycle handling.
- Check state transitions are explicit and cannot skip a required step.
- Check date, currency, locale and timezone logic is deterministic.
- Check retries, idempotency and duplicate events wherever messages, webhooks or
  payments are handled.
- Compare output shapes with the existing API contracts and types.
- Say whether tests use realistic data or only toy fixtures.

## 4. Tests (the oracle)
- List every changed test, fixture, snapshot, CI, lint and type-config file,
  each marked stricter, looser or neutral.
- For each new test, name the bug it catches. FAIL a test that passes with the
  feature removed.
- Confirm at least one failure-path test per changed behaviour.
- Flag mocks inside the logic under test instead of at system boundaries.
- Flag regenerated snapshots, sleeps, fixed waits and live network calls.
- Run the project's test, type-check and lint commands. Paste each command and
  its exit status, and the commit SHA they ran on.

## 5. Security and privacy
- Validate every new input at the boundary.
- Check authorization separately from authentication on every new route or action.
- Trace every user-controlled value into SQL, shell, file paths, HTML and URLs.
- Check no secret is logged, returned, committed or shipped in the client bundle.
- List any widened permission, OAuth scope, CORS, CSP or webhook trust, with its reason.
- Check sensitive data is redacted in logs, analytics and error messages.
- Check uploads, redirects and callbacks are limited to expected origins and types.
- For every new dependency, confirm it exists on the registry under the intended
  name and is maintained.

## 6. Data and migrations
- Check schema changes stay compatible during a rolling deploy.
- Check migrations are idempotent or ship a rollback, and preserve existing data.
- Check new queries use an index or a bounded scan where volume matters.
- Check jobs and webhooks tolerate duplicate delivery.
- Check deletes are soft, recoverable, or justified in the PR description.

## 7. Performance and operations
- Flag unbounded loops, N+1 queries and repeated network calls.
- Check expensive work is cached, batched, queued or paginated.
- Report client bundle growth from new imports, if the build reports sizes.
- Check errors carry enough context to debug without private data.
- Check new critical paths have monitoring, alerting or analytics.
- Check security-sensitive paths fail closed and UX paths fail gracefully.

## 8. Reviewability
- Report changed lines excluding generated files. FAIL above 400 lines.
- Flag formatting-only churn and generated code that was not simplified.
- Flag comments that restate the code instead of explaining a decision.
- Check screenshots or traces are attached for visual or operational changes.
- Name the single riskiest hunk and why, in two sentences.

## 9. Escalation classes
List every touched path in these classes: auth, permissions, tenancy, admin;
billing, payments, refunds, pricing; schema and migrations; public API, SDK and
webhook contracts; privacy, deletion, export, consent; rate limits, abuse
prevention, security headers; tests, CI, lint and type config.

## Output, in this order
1. Findings, P0 first.
2. Checklist results: PASS, FAIL or N/A with evidence, per item.
3. Escalation classes touched, with paths.
4. Suggested verdict: APPROVE, RETURN or ESCALATE, and the reason.
```

Budżet 400 linii w sekcji 8 to wartość wyjściowa; ustaw go na budżet rozmiaru, który zespół uzgodnił w [kolejce code review](/pl/teams/review-queue/). Proponowany werdykt jest tylko propozycją: agent recenzujący nigdy nie akceptuje ani nie scala zmian.

## Które zmiany wciąż czyta człowiek?

Sekcja 9 checklisty wskazuje te klasy. W każdej wskazana osoba czyta też kod, bo wyrocznia jest słaba, informacja zwrotna przychodzi powoli albo szkodę trudno odwrócić.

| Klasa eskalacji | Dlaczego dowody nie wystarczą | Pytanie, na które odpowiada czytający kod |
| --------------- | ----------------------------- | ----------------------------------------- |
| **Uwierzytelnianie, autoryzacja, uprawnienia, tenancy, funkcje administracyjne** | Testy dowodzą dozwolonych ścieżek; błąd kryje się w ścieżce, której nikt nie przetestował | Czy jakikolwiek wywołujący dotrze do danych lub akcji, do których nie powinien? |
| **Pieniądze: rozliczenia, płatności, zwroty, cennik** | Błędy zaokrągleń i idempotencji wychodzą po tygodniach, na kontach klientów | Czy każda kwota jest liczona raz, poprawnie zaokrąglona i bezpieczna przy ponowieniu? |
| **Schematy i migracje zmieniające dane produkcyjne** | Często nieodwracalne i uruchamiane na danych, których fixture'y nie przypominają | Czy da się ją uruchomić dwa razy i jak ją wycofamy? |
| **Kontrakty publicznego API, SDK i webhooków** | Awaria wychodzi w cudzym kodzie, poza testami tego repozytorium | Który istniejący klient się zepsuje i czy to zadeklarowano? |
| **Prywatność i zgodność: usuwanie, eksport, zgody, retencja** | Skutkiem jest ryzyko prawne, a nie czerwony test | Czy dane osobowe trafiają tylko tam, gdzie pozwala polityka? |
| **Ochrona przed nadużyciami i incydentami: limity, anti-abuse, nagłówki bezpieczeństwa** | Liczą się pod atakiem, którego testy rzadko symulują | Czy pod naciskiem zamyka dostęp, zamiast go otwierać? |
| **Wyrocznia: testy, CI, linter i konfiguracja typów** | Zmienia znaczenie „zielonego” dla każdej innej zmiany | Czy zielone wciąż znaczy to samo co wczoraj? |
| **Wszystko, czego nie pokrywa żadne sprawdzenie, albo gdy dowody i agent recenzujący się nie zgadzają** | Bez wyroczni jedynym dowodem jest kod | Jak wyglądałby test tego zachowania i kto go napisze? |

Pięć wierszy odpowiada tabeli eskalacji na stronie o [czytaniu dowodów zamiast kodu](/pl/ladder/evidence-not-diffs/), a trzy pochodzą z dawnej checklisty. Zostaw klasę tylko wtedy, gdy odpowiada jej niewielki zestaw ścieżek; lista eskalacji obejmująca pół repozytorium cofa cię na poziom 3. Wymuś listę przez `CODEOWNERS` plus regułę ochrony gałęzi „Require review from Code Owners”:

```text title=".github/CODEOWNERS"
/src/auth/            @acme/security-reviewers
/src/billing/         @acme/payments-owners
/db/migrations/       @acme/data-owners
/tests/               @acme/tech-leads
/.github/             @acme/tech-leads
```

## Gdzie jest review człowieka wśród pozostałych warstw sprawdzeń?

Ocena z poprzednich sekcji to jedna z kilku warstw. W artykule „How the Claude Code team does code review” (Addy Osmani, Morgan Westlee Lunt i Qing Wang, blog claude.dev, 15 października 2026) review było dawniej „a gate at the end of the road: write the code, open a PR, wait for your colleague”. Teraz „runs continuously, more like spellcheck while you write”, a większość zmian przeszła przez review i poprawki Claude'a co najmniej raz, zanim ktoś poprosił o nie człowieka. Liczby z artykułu to dane, które Anthropic podaje o własnych repozytoriach, więc nie traktuj ich jako benchmarku.

Artykuł mówi o „Six layers of checks, with rollback under them” i dzieli opis na siedem numerowanych sekcji. Poniższa tabela to nasz własny podział na osiem wierszy, w kolejności, w jakiej zmiana mija kolejne warstwy:

| Warstwa | Co opisuje zespół Claude Code | Jak ją ustawić |
| ------- | ----------------------------- | -------------- |
| 1. Weryfikacja przed pull requestem | Claude pokazuje wynik testów, builda albo porównania zrzutu ekranu, a potem subagent robi review diffa ze świeżym kontekstem. Powtarzające się uwagi naprawia się u źródła: w skillu, regułą lintera albo w plikach z instrukcjami | [Pakiet dowodów](/pl/workflows/ship/evidence-bundle/) i checklista z tej strony |
| 2. Review AI w każdym pull requeście | Recenzent czyta diff na tle całego repozytorium i deklarowanego celu pull requesta | [Boty do AI code review](/pl/ecosystem/observability/ai-code-review-bots/) |
| 3. Przegląd bezpieczeństwa, który może blokować | Pull request nie może zostać scalony, dopóki otwarte jest jakiekolwiek znalezisko z review błędów lub bezpieczeństwa | [Bramki bezpieczeństwa dla kodu agentów](/pl/ecosystem/observability/agent-security-gates/) i reguła rozmów poniżej |
| 4. Wymagane CI | „lint, type checks, tests on every platform, and a build” | [Automatyzacja pipeline'ów z AI](/pl/workflows/ship/ci-cd-pipelines/) i szablon poniżej |
| 5. Zatwierdzenie przez człowieka skalowane ryzykiem | Jeden poziom nie wymaga nikogo, drugi jednej osoby, trzeci dwóch | Klasy eskalacji powyżej i [kolejka code review](/pl/teams/review-queue/) |
| 6. Merge queue | Ponownie uruchamia wszystkie sprawdzenia na `main` z naniesioną zmianą, „so two PRs that pass separately can't combine into a broken main” | Merge queue w twojej platformie Git |
| 7. Flagi i etapowe wydanie | Najpierw flaga dla pracowników Anthropic; kanał `latest` przed `stable` | [Progressive delivery](/pl/workflows/ship/progressive-delivery/) |
| 8. Szybkie wykrycie i wycofanie | Flagi wyłączane bez wdrożenia, cotygodniowy dyżur on-call i przeglądy incydentów, które pytają, która warstwa powinna była problem wyłapać | [Progressive delivery](/pl/workflows/ship/progressive-delivery/) i [incydenty agentów](/pl/org/agent-incidents/) |

Anthropic pisze, że nie ma jeszcze wyłączników awaryjnych, które zaostrzałyby zatwierdzanie, gdy rosną liczby rewertów i incydentów, i że jego inżynierowie chcą je mieć, zanim więcej kodu trafi do merge'y bez człowieka. Gdy defekt się prześlizgnie, zrób to, czym artykuł się kończy: zapytaj, która warstwa powinna go wyłapać i czego recenzent nie miał przed sobą, a potem wpisz poprawkę do pliku z instrukcjami, do skilla albo do nowego sprawdzenia. Tak samo ta strona traktuje fragment z próbki, w którym wyszedł realny problem. Przy ludziach zostaje pięć decyzji: czy w ogóle budować zmianę, ryzykowny kod, taki jak rozliczenia i workflowy CI, architektura wyznaczająca wzorzec, czytanie dowodów i odpowiedzialność za wynik. Pierwszej nie obejmuje żadna klasa eskalacji powyżej; jak ją zgłosić, opisuje [kolejka code review](/pl/teams/review-queue/).

## Jak sprawić, żeby każde znalezisko review dostało odpowiedź?

Reguła Anthropic dla własnych repozytoriów brzmi „Every finding has to be answered”: albo naprawiasz znalezisko, albo zamykasz wątek z podaniem powodu. Agent często podejmuje poprawkę w nocy, a późniejszy commit naprawiający problem sam zamyka znalezisko. Twoje narzędzie może tego nie wymuszać: dokumentacja Claude Code (przeczytana 2026-10-16) mówi, że review w Claude Code Review „never approves or blocks the pull request”, a jego check run nigdy nie kończy się porażką. Dodaj tę regułę sam:

1. **Wymagaj rozwiązania rozmów.** W regule ochrony gałęzi lub rulesecie dla gałęzi domyślnej włącz „Require conversation resolution before merging”. To ustawienie gałęzi, więc obejmuje wątki od dowolnego recenzenta.

2. **Powiedz autorom, jak zamyka się wątek.** Wypchnij poprawkę i pozwól, żeby przeszło kolejne review; rozwiązuje ono wątek, gdy uzna, że problem naprawiono. Samo z siebie startuje tylko w repozytoriach ustawionych na review przy każdym pushu. W repozytoriach z „Once after PR creation” albo ręcznych autor komentuje `@claude review`. Wątek można też rozwiązać ręcznie. Sama odpowiedź nie zamyka znaleziska.

3. **Bramkuj według wagi, gdy rozwiązywanie wątków to za mało precyzyjna bramka.** Check run zawiera liczbę znalezisk według wagi, którą może odczytać krok CI; workflow jest na [stronie o botach do review](/pl/ecosystem/observability/ai-code-review-bots/).

## Jak dodać Testing, Risk i How to revert do szablonu pull requesta?

Lista wdrożeniowa z artykułu dodaje do szablonu pull requesta „Testing”, „Risk” i „How to revert”. Claude może go wypełnić, ale „the person who asked for the change signs off on it”. Krótką wersję zapisz jako `.github/pull_request_template.md`:

```markdown title=".github/pull_request_template.md"
## What changed and why

## Testing
<!-- The commands you ran, their results and the commit SHA they ran on.
     For a UI change, a screenshot of each acceptance path. -->

## Risk
<!-- Low, standard or high, and why. Name every path from the escalation list
     that this change touches, and what breaks if the change is wrong. -->

## How to revert
<!-- One step: revert the merge commit, turn off the flag, or roll back the
     migration. Say how long it takes. -->

## Sign-off
- [ ] I asked for this change and stand behind Testing, Risk and How to revert.
```

Agent może wypełnić każdą sekcję, ale pole zaznacza tylko osoba, która poprosiła o zmianę. Jeśli używasz [pakietu dowodów](/pl/workflows/ship/evidence-bundle/), jego szablon zastępuje ten: Testing odpowiada wpisom `acceptance` i `checks`, Risk polom `risk.class` i `risk.touches`, a How to revert polu `risk.rollback`, a sprawdzenie CI z tej strony może oblać pustą sekcję.

## Dlaczego pętla review agenta potrzebuje limitu rund?

Agent-autor i agent recenzujący mogą bez końca dokładać sobie nawzajem pracy. Anthropic podaje, że jeden pull request do CLI przeszedł w nocy ponad 50 rund review i poprawek, zanim autor go zatrzymał. Git blame na tym, co recenzent wciąż zgłaszał, pokazał, że około 59% dotyczyło kodu obecnego od pierwszego przejścia recenzenta: „The reviewer was rarely finding new bugs, it was finding a few more old ones each round.” Domyślne puszczanie kilku rund jeszcze to pogorszyło. Przy ryzykownej zmianie się opłaca, ale nie przy każdym pull requeście.

Zespół zmienił ponowne review na cztery sposoby:

- **Limit rund.** Po trzech rundach recenzent prosi autora, żeby się cofnął i przemyślał podejście.
- **Review samego diffa** po pierwszych kilku przejściach.
- **Oznaczenie klasy błędu**, żeby autor naprawił każde wystąpienie, a nie jedną linię.
- **Bez powtórzeń** znalezisk, które już opublikowano.

Teraz zespół śledzi liczbę rund do zaliczenia (rounds-to-pass) obok czułości (recall, czyli odsetka znanych błędów, które znajduje recenzent). Śledzenie obu naraz sprawia, że jedna nie poprawia się kosztem drugiej; to nasz wniosek, a nie teza artykułu. Rysunek FIG D z artykułu pokazuje wewnętrzne pull requesty Anthropic przed zmianami i po nich:

| Miara | Przed | Po |
| ----- | ----- | -- |
| Zaliczone po jednej rundzie review i poprawek | 65% | 78% |
| Wymagające pięciu lub więcej rund | 8,9% | 1,5% |
| Średnia liczba review do zaliczenia | 2,08 | 1,32 |

Artykuł nie podaje dat ani liczebności grup, więc weź z tego kierunek zmiany, a własne cele ustaw na swoich danych. Limit Anthropic liczy rundy review AI i poprawek; limit dwóch zwrotów z tabeli werdyktów liczy, ile razy ocena człowieka odsyła pull request do agenta-autora. Oba wymuszają zmianę podejścia i oba to wartości wyjściowe. Gdzie leży każdy mechanizm, zależy od narzędzia:

- **Claude Code:** późniejsze automatyczne review w Claude Code Review już skupiają się na tym, co zmieniło się od poprzedniego review, i publikują mniej nitów oraz znalezisk typu Pre-existing (dokumentacja Claude Code, przeczytana 2026-10-16). Wpisz do `REVIEW.md` „Report at most five Nits” i „After the first review of a PR, post Important findings only”, jak pokazuje [strona o botach do review](/pl/ecosystem/observability/ai-code-review-bots/).
- **Codex:** reguły review dla `@codex review` leżą w `AGENTS.md` (sprawdzone 2026-08-28, jak zapisano w zakładce Codex poniżej). `codex exec review` to przebieg review; pętlę, która commituje poprawki, jak w prompcie poniżej, uruchom zwykłym `codex exec`: `codex exec -s workspace-write -` czyta prompt ze standardowego wejścia (sprawdzone przez `--help` w codex-cli 0.162.0-alpha.17.2, wersji alpha).
- **Cursor:** Bugbot czyta reguły projektu z `.cursor/BUGBOT.md` (źródło wtórne, według strony o botach do review).

## Jak uruchomić agenta recenzującego w Claude Code, Codeksie i Cursorze?

Checklista i ocena są takie same we wszystkich trzech narzędziach. Różni się miejsce, w którym działa agent recenzujący, i to, czy może pisać w pull requeście.

**Claude Code**

    Uruchom checklistę bez interfejsu, z terminala albo z CI. Sesje `claude -p` startują w trybie uprawnień Manual (od v2.1.285 w trybie auto u zewnętrznych dostawców lub z wyłączoną telemetrią, gdzie decyduje klasyfikator), więc poniższe polecenie przekazuje `--permission-mode dontAsk`, żeby u każdego dostawcy blokować każde wywołanie narzędzia, które wymagałoby pytania (odczyty plików w katalogach roboczych i polecenia Bash tylko do odczytu nadal działają), chyba że dopuszczają je własne ustawienia projektu z tej gałęzi. Sekcja 4 checklisty uruchamia polecenia testów, sprawdzania typów i lintera oraz zapisuje SHA commita, więc wszystkie muszą być na liście dozwolonych; zamień pisownię `npm` na polecenia swojego projektu:

    ```bash
    # Terminal or CI, from the repository root (Claude Code 2.1.283)
    claude -p "$(cat .github/review/agent-checklist.md)" \
      --permission-mode dontAsk \
      --allowedTools "Read,Grep,Glob,Bash(git diff *),Bash(git log *),Bash(git rev-parse *),Bash(npm test *),Bash(npm run typecheck *),Bash(npm run lint *)" \
      --output-format json --max-budget-usd 2 > review.json
    ```

    **W CI gałąź w review to niezaufane wejście**

    CLI ładuje z gałęzi jej własne hooki z `.claude/settings.json` i plik `.mcp.json`, jej reguły `permissions.allow` w ustawieniach projektu mogą poszerzyć listę dozwolonych, a dozwolone `npm test` uruchamia kod tej gałęzi ze wszystkimi sekretami, jakie ma zadanie. W CI dodaj `--strict-mcp-config` i nie trzymaj sekretów w środowisku zadania. Przy forkach i innych niezaufanych wyzwalaczach pobierz zaufane skrypty z gałęzi domyślnej, commit kontrybutora umieść w osobnym katalogu, który agent tylko czyta, i nie ładuj z niego żadnych ustawień projektu (`--bare --setting-sources "" --strict-mcp-config`). Testy zostaw zadaniu CI bez uprawnień, a agent niech cytuje jego wyniki.

    Drugie przejście pod kątem poprawności daje wbudowane `/code-review` w sesji. Dla pull requestów z klas eskalacji `claude ultrareview 482` uruchamia w chmurze wieloagentowe review pull requesta 482, a każde znalezisko jest niezależnie odtworzone. Po trzech darmowych uruchomieniach na planach Pro i Max jest rozliczane w kredytach użycia (zwykle od 5 do 25 USD za uruchomienie); nie jest dostępne na Bedrocku, Google Cloud i Foundry ani dla organizacji z Zero Data Retention.

    Do kroku 4 przyda się plugin Anthropic `pr-review-toolkit`, skupiony na testach i cichych awariach:

    ```bash
    claude plugin install pr-review-toolkit@claude-plugins-official
    ```

    Potem, w sesji na gałęzi: `/pr-review-toolkit:review-pr tests errors`. Zarządzana usługa Code Review (Team i Enterprise) czyta `REVIEW.md`, więc skopiuj tam checklistę. Review nigdy nie zatwierdza ani nie blokuje pull requesta, a jego check run nigdy nie kończy się porażką (dokumentacja Claude Code, przeczytana 2026-10-16), więc publikuje komentarze i sam nie jest bramką. Żeby jego znaleziska blokowały merge, zastosuj [wskazówki, jak sprawić, żeby każde znalezisko review dostało odpowiedź](#jak-sprawić-żeby-każde-znalezisko-review-dostało-odpowiedź).

**Codex**

    `codex exec review` przegląda repozytorium bez interakcji i przyjmuje własne instrukcje jako prompt; `-` czyta je ze standardowego wejścia. Zakres wyznacza pierwsza linia checklisty, „Review the changes on this branch against main”:

    ```bash
    # Terminal or CI, from the repository root (Codex CLI 0.157.1)
    codex exec review - -c sandbox_mode="workspace-write" -o review.md < .github/review/agent-checklist.md
    ```

    Sekcja 4 checklisty uruchamia testy, a wiele narzędzi testowych zapisuje cache albo pliki pokrycia, co w piaskownicy tylko do odczytu kończy się błędem; stąd `sandbox_mode="workspace-write"` (`exec review` nie ma flagi `-s` w Codex CLI 0.157.1). W CI traktuj gałąź jako niezaufaną: nie trzymaj sekretów w środowisku zadania, a przy forkach niech testy uruchomi zadanie bez uprawnień, a agent tylko cytuje wyniki.

    `--base`, `--commit` i `--uncommitted` to presety, których nie da się łączyć z własnymi instrukcjami (sprawdzone w Codex CLI 0.157.1). Dodaj `--output-schema verdict.schema.json`, gdy krok CI potrzebuje werdyktu w JSON. Na GitHubie i GitLabie skomentuj pull request `@codex review`; reguły review są w `AGENTS.md` (sprawdzone 2026-08-28), więc dopisz tam linię „Apply `.github/review/agent-checklist.md` to every review”, a obie ścieżki będą stosować ten sam standard.

**Cursor**

    Otwórz agenta na gałęzi pull requesta i wklej pierwszy prompt poniżej; każe on agentowi przeczytać plik checklisty, więc nie trzeba konfigurować reguł. Raport agenta opublikuj jako pierwszy komentarz w pull requeście.

    W pull requeście Bugbot szuka błędów i problemów bezpieczeństwa, a PR Routing & Approval przydziela recenzentów według własności kodu i może akceptować pull requesty niskiego ryzyka, które spełniają twoje kryteria (sprawdzone na cursor.com, 2026-08-28). Ustaw tabelę eskalacji jako kryteria akceptacji: automatyczna akceptacja jest dozwolona tylko wtedy, gdy żadna klasa eskalacji nie jest dotknięta. Zobacz [PR Routing & Approval w Cursorze](/pl/cursor-ide/ship/rollouts-and-approval/).

Uruchamiaj agenta recenzującego w nowej sesji, nie w tej, która napisała kod i przeniosłaby do review te same założenia. Porównanie botów do code review od dostawców narzędzi i firm trzecich pod kątem szumu i konfiguracji znajdziesz w [zestawieniu botów do AI code review](/pl/ecosystem/observability/ai-code-review-bots/). Jak podzielić review na osobne przejścia dla poprawności, bezpieczeństwa, testów i zgodności ze specyfikacją przed akceptacją człowieka, opisuje strona o [warstwowym review pull requestów](/pl/developer-scorecard-guide/layered-pr-review/).

## Prompty do skopiowania do code review PR-a agenta

**Prompt do skopiowania: uruchom checklistę agenta recenzującego**

```text
Review the changes on this branch against main using the checklist in
.github/review/agent-checklist.md. Read that file first and follow its output
format exactly.

Rules:
- Do not edit, commit, approve, merge or comment on the pull request.
- Run the test, type-check and lint commands from package.json yourself and
  paste each command, its exit status and the commit SHA. Never infer a result.
- Evidence for every item is a command and exit status, a file:line, or a
  search result. "Looks fine" is not evidence.
- Report only findings that could matter in production.

End with the escalation classes touched (with paths) and a suggested verdict:
APPROVE, RETURN or ESCALATE, with a one-sentence reason.
```

**Prompt do skopiowania: wybierz fragmenty do przeczytania przez człowieka**

```text
I will read at most three hunks of this branch's diff against main. Choose two
of them for me, applying these rules in order and stopping at the first two
matches: <paste the hotspot order from step 5 of the triage>.

For each hunk give: file and line range, the rule it matched, and the one
question I should answer while reading it. Do not summarise the code; I will
read it myself. Do not choose test files.
```

**Prompt do skopiowania: zwróć pull request agentowi-autorowi**

```text
This pull request was returned in review. The failing items are below. Fix
exactly these and nothing else.

<paste the FAIL lines and findings from the review report here>

For each item:
1. Make the smallest change that fixes it.
2. If the item is a missing or weak check, add the test first and show it
   failing on the current code before you fix the code.
3. Do not edit, skip or loosen any existing test, snapshot, CI or lint file.
   If you believe one is wrong, stop and explain why instead of changing it.

When done, rerun the full checklist in .github/review/agent-checklist.md and
update the PR's evidence section with results for the new head commit.
```

Trzeci prompt służy tylko do pierwszej i drugiej rundy. Po drugim zwrocie człowiek czyta pull request albo przepisuje specyfikację.

**Prompt do skopiowania: pętla review, która się zbiega**

```text
Run a review-and-fix loop on this branch against main. Stop conditions first:
after three rounds, stop. Never start a fourth.

Round 1: review the whole diff with the checklist in
.github/review/agent-checklist.md.
Rounds 2 and 3: review only the lines changed since the previous round, plus
any other instance of a bug class already reported. Do not post a finding that
an earlier round already posted; refer to it instead.

For every finding:
1. Name its class of bug, for example "unchecked error on an external call".
2. Search the whole diff for other instances of that class and fix all of
   them in one commit, not only the line reported.
3. Fix the finding, or answer it with a reason that starts "wrong:" or
   "intentional:". Never leave a finding unanswered.

If findings remain after round 3, stop and write a note for the author:
- what kept coming back, grouped by class,
- how many findings in rounds 2 and 3 pointed at lines that were already in
  the diff in round 1,
- whether to reconsider the approach, and what a simpler one would be.

Never edit, skip or loosen a test, snapshot, CI or lint file to make a finding
go away. Report the rounds used and the commit SHA after each round.
```

Czwarty prompt służy do pętli, którą agent przechodzi sam: po trzech rundach się zatrzymuje i oddaje decyzję człowiekowi.

## Skąd wiesz, że ocena PR-ów działa?

Sama ocena też potrzebuje dowodów. Śledź cztery liczby dla każdej klasy zmian, co miesiąc:

| Miara | Definicja | Co mówi zły trend |
| ----- | --------- | ----------------- |
| **Trafność próbki** | Odsetek przeczytanych fragmentów, w których człowiek znalazł realny problem pominięty przez dowody i agenta recenzującego | Rośnie: dowody mają lukę. Napisz brakujące sprawdzenie i obserwuj, jak wskaźnik spada |
| **Odsetek defektów przepuszczonych na produkcję** | Defekty produkcyjne powiązane z pull requestami zaakceptowanymi w ocenie, podzielone przez wszystkie akceptacje z oceny | Rośnie: klasa jest akceptowana za wcześnie; cofnij ją do próbkowania albo pełnego czytania |
| **Rundy zwrotów** | Średnia liczba zwrotów na pull request przed akceptacją | Powyżej dwóch: niejasne są specyfikacje, a nie jakość kodu |
| **Precyzja agenta recenzującego** | Znaleziska przyjęte przez człowieka podzielone przez wszystkie zgłoszone znaleziska | Spada: checklista produkuje szum; zawęź ją, zanim ludzie przestaną czytać raport |

Zespół Claude Code w Anthropic śledzi liczbę rund do zaliczenia obok czułości; [strona o botach do review](/pl/ecosystem/observability/ai-code-review-bots/#skąd-wiesz-że-recenzent-się-poprawił-a-nie-tylko-zmienił) pokazuje, jak zmierzyć czułość. Odpowiedzialność pozostaje jawna: nazwisko osoby akceptującej jest na każdym zaakceptowanym pull requeście, code ownerzy z `CODEOWNERS` zatwierdzają klasy eskalacji, a tech lead zmienia checklistę i listę eskalacji tylko przez pull requesty, które przeszły review. Kanoniczne wersje tych miar są razem z innymi metrykami zespołu w [ramach metryk dla inżynierii agentowej](/pl/org/metrics-frameworks/), a etapowe wdrożenie, które przenosi na ten protokół cały zespół, opisuje strona [jak pomóc zespołowi przestać czytać każdy diff](/pl/teams/trust-transfer/).

## Co się psuje przy ocenie pull requestów agenta?

**Agent recenzujący zasypuje cię drobiazgami.** Czterdzieści znalezisk, większość o nazewnictwie, a jedyny prawdziwy błąd jest trzydziesty pierwszy. Naprawa: trzymaj się reguły „no style comments” z checklisty, proś tylko o znaleziska P0–P2 i śledź precyzję agenta recenzującego. Gdy spada, usuń punkty checklisty, które produkują szum.

**Autor i recenzent mają ten sam martwy punkt.** Ten sam model, w tej samej sesji, z tym samym kontekstem dwa razy źle odczytuje specyfikację. Naprawa: uruchamiaj review w nowej sesji, a w klasach eskalacji użyj innego narzędzia albo głębszego przejścia (`claude ultrareview`, `@codex review`, Bugbot). Opinia agenta recenzującego nie jest dowodem; są nim tylko sprawdzenia, które się wykonały.

**Wyniki dotyczą innego commita.** Agent uruchomił testy, potem wypchnął poprawkę, a zielone sprawdzenia należą do poprzedniego commita. Naprawa: wymagaj SHA commita przy każdym poleceniu w raporcie i niech ostatecznym źródłem wyników testów będzie CI, a nie agent.

**Próbkowanie zamienia się w przeglądanie po łebkach albo zanika.** Pod presją „trzy fragmenty” stają się „rzuciłem okiem”. Naprawa: zapisuj przeczytane fragmenty w komentarzu z werdyktem, losowy plik wybieraj poleceniem, a nie na oko, i licz pull requesty bez zapisanej próbki jako niesprawdzone.

**Zwrócone pull requesty kręcą się w kółko.** Agent-autor poprawia jedno znalezisko i psuje inne. Naprawa: zatrzymaj się po dwóch zwrotach. Przed trzecią próbą przepisz specyfikację albo jej kryteria akceptacji; zobacz, [jak pisać kryteria akceptacji, których agent nie odczyta źle](/pl/workflows/plan/acceptance-criteria/).

**Recenzent wciąż znajduje stary kod.** Każda runda zgłasza kilka kolejnych problemów, które były już w pierwszym diffie, a agent-autor poprawia każdy w nowym commicie. Naprawa: zastosuj [limit rund i jego mechanizmy](#dlaczego-pętla-review-agenta-potrzebuje-limitu-rund).

**Lista eskalacji pochłania wszystko.** Każdy pull request dotyka „wspólnego” kodu, więc każdy jest eskalowany, i znowu czytasz diffy. Naprawa: eskaluj według ścieżek w `CODEOWNERS`, a nie według uznania, i dodawaj klasę tylko przez zmianę tego pliku, która przeszła review.

**Wiarygodnie wyglądająca zależność nie istnieje.** Kod importuje pakiet o sensownej nazwie, który nigdy nie został opublikowany albo opublikował go atakujący. Naprawa: zachowaj punkt o zależnościach w sekcji 5 checklisty i dodaj do CI sprawdzenie rejestru opisane w [kontroli zależności dla zmian agentów](/pl/workflows/test/dependency-verification/).

## Dokąd dalej po code review PR-a agenta

- [Pakiet dowodów](/pl/workflows/ship/evidence-bundle/) — Kontrakt pull requesta stojący za krokiem 2 i sprawdzenie CI, które odrzuca niekompletny pakiet.
- [Czytanie dowodów zamiast kodu](/pl/ladder/evidence-not-diffs/) — Teza, którą ten protokół wprowadza w życie, z osobistym dziennikiem zaufania.
- [Ochrona wyroczni](/pl/workflows/test/protect-the-oracle/) — Jak trzymać sprawdzenia z kroku 4 poza zasięgiem agenta.
- [Ewaluacja botów do AI code review](/pl/ecosystem/observability/ai-code-review-bots/) — Zbuduj zestaw ewaluacyjny z własnych incydentów, zmierz szum i dostrajaj recenzenta najpierw na jednym repozytorium.
- [Kolejka code review](/pl/teams/review-queue/) — Budżety rozmiaru, ścieżki ryzyka i obciążenie recenzentów, gdy pull requesty otwierają agenci.
- [Jak pomóc zespołowi przestać czytać każdy diff](/pl/teams/trust-transfer/) — Etapy shadow, próbkowania i samych dowodów, dla każdej pętli.
- [Warstwowe review pull requestów](/pl/developer-scorecard-guide/layered-pr-review/) — Osobne przejścia dla poprawności, bezpieczeństwa, testów i zgodności ze specyfikacją przed akceptacją człowieka.
- [Ograniczona pętla review i poprawek](/pl/developer-scorecard-guide/auto-pr-workflow/) — Automatyzacja ścieżki zwrotu z warunkiem zatrzymania po dwóch rundach.
