# Boty do AI code review: Claude Code Review, Codex, Bugbot, CodeRabbit, Greptile i inne

URL: https://developertoolkit.ai/pl/ecosystem/observability/ai-code-review-bots/
Description: Który bot do AI code review i gdzie: Claude Code Review, codex review, Copilot, Bugbot, CodeRabbit, Greptile i ocr: wyzwalacz, konfiguracja i koszt na PR.

Boty do AI code review to drugie modele, które czytają diff i publikują uwagi, zanim człowiek zatwierdzi zmianę. We wrześniu 2026 główne opcje to Claude Code Review, `claude-code-action`, `codex review`, GitHub Copilot code review, Bugbot od Cursora, CodeRabbit, Greptile i otwartoźródłowy `ocr` od Alibaby. Jeden bot nie wystarczy: uruchamiaj je warstwami i mierz każdy precyzją oraz kosztem na pull request.

Twój zespół co miesiąc merge'uje coraz więcej pull requestów, w większości napisanych przez agentów, a code review stało się kolejką, w której wszyscy czekają. Ktoś instaluje bota, ten zostawia 30 komentarzy pod pierwszym pull requestem i po tygodniu ludzie zamykają jego wątki bez czytania. Ta strona jest dla programistów, którzy chcą przed pushem drugiej opinii, której mogą ufać, i dla tech leadów, którzy muszą wybrać, skonfigurować i opłacić boty, z którymi żyje cały zespół.

## Co daje ci to porównanie botów do code review

- **Tabelę porównawczą** jedenastu opcji: gdzie działa każda z nich, co je uruchamia, który plik je stroi i ile kosztuje jedno review.
- **Czterowarstwowy proces code review** (samodzielne review lokalnie, drugi model, bot na pull requeście, człowiek) z kolejnością i kosztem każdej warstwy.
- **Workflow `claude-code-action@v1`** zaadaptowany z dokumentacji Anthropic, plik `REVIEW.md` ograniczający szum i workflow, który zamienia neutralny check run w wymagany status check.
- **Odpowiednik tej konfiguracji dla Codeksa i Cursora** oraz polecenia instalacji Greptile, CodeRabbit i `ocr`.
- **Sześć promptów do skopiowania**, cztery metryki, które pokazują, czy bot zarabia na siebie, i pułapki, przez które każde z narzędzi się myli.
- **Zestaw ewaluacyjny zbudowany z własnych pull requestów, które wywołały incydenty, i rewertów**, pomiar szumu według tego, co autorzy robią z każdym komentarzem, wzorzec weryfikacji odrzucający znaleziska dotyczące samego stylu i wdrożenie zaczynane od jednego repozytorium.

Ta strona porównuje boty. Procedurę, którą człowiek przechodzi na pull requeście agenta, opisuje [code review PR-a agenta bez czytania każdej linii](/pl/workflows/ship/agent-pr-review/); zacznij od niej, jeśli nie masz jeszcze checklisty do code review.

## Który bot do AI code review pasuje do którego zadania?

Każde narzędzie poniżej sprawdziliśmy 2026-09-26 w dokumentacji dostawcy, w jego repozytorium na GitHubie lub w npm albo w zainstalowanych CLI (Claude Code 2.1.283, Codex CLI 0.157.1). Wiersze oznaczone jako **wtórne** opierają się na wyciągach z wyszukiwarki albo na sprawdzeniu z 2026-08-28, a nie na stronie dostawcy przeczytanej tego dnia; potwierdź je u dostawcy, zanim wdrożysz. Wiersz Claude Code Review i zakładkę Claude Code sprawdziliśmy ponownie z dokumentacją Claude Code pobraną 2026-10-16.

| Narzędzie | Gdzie działa | Wyzwalacz | Co je stroi | Koszt jednego review | Źródło |
| --------- | ------------ | --------- | ----------- | -------------------- | ------ |
| **Claude Code Review** (Team i Enterprise) | Infrastruktura Anthropic, GitHub | Otwarcie PR, każdy push albo `@claude review` | `REVIEW.md`, `CLAUDE.md` | Rozliczane jako usage credits; ogłoszenie premiery (9 marca 2026) podawało, że review „generally average $15–25”, a twoją średnią pokazują ustawienia administratora | Dokumentacja dostawcy i ogłoszenie premiery |
| **`/code-review`** (każdy plan) i **`claude ultrareview`** | Twój terminal; ultrareview w chmurze Anthropic | Uruchamiasz sam | `CLAUDE.md` (nie `REVIEW.md`) | Zwykłe użycie; ultrareview: 3 darmowe uruchomienia na Pro i Max, potem „typically $5 to $25” | Dokumentacja dostawcy, CLI |
| **`claude-code-action@v1`** | Twój runner GitHub Actions | Wybrane przez ciebie zdarzenia workflow | Prompt, plugin, `CLAUDE.md` | Tokeny z twojego klucza API lub subskrypcji | Dokumentacja dostawcy |
| **`codex review`** i **`openai/codex-action@v1`** | Twój terminal lub runner | Uruchamiasz sam; zdarzenia workflow | Własne instrukcje, `AGENTS.md` | Limity Codeksa albo tokeny API | Pomoc CLI, README akcji |
| **`@codex review`** na GitHubie | Chmura OpenAI | Komentarz w PR | `AGENTS.md` | Plan Codeksa | **Wtórne** (sprawdzone 2026-08-28) |
| **GitHub Copilot code review** (płatne plany Copilota; nie Copilot Free) | GitHub; agentowe zbieranie kontekstu działa na runnerach Actions | Prośba o review od Copilota w sekcji **Reviewers** albo ustawienie automatycznego review lub ruleset | `.github/copilot-instructions.md`, `.github/instructions/*.instructions.md`, `AGENTS.md` | AI credits: szacunkowo 0,05–1 USD za review przy effort Lite, 0,25–5 USD przy Balanced, plus minuty Actions | github/docs |
| **Cursor Bugbot** | Chmura Cursora, GitHub i GitLab | Otwarcie lub aktualizacja PR, `bugbot run` | `.cursor/BUGBOT.md` | Według zużycia; Cursor podaje, że przeciętny przebieg kosztuje od 1,00 do 1,50 USD (sprawdzone 2026-10-12) | Koszt: dokumentacja i blog Cursora; wyzwalacz i `BUGBOT.md`: **wtórne** |
| **CodeRabbit** (aplikacja i CLI) | Chmura dostawcy; CLI lokalnie | PR; `coderabbit review` | Konfiguracja dostawcy | Niezweryfikowany | Flagi CLI z oficjalnego skilla CodeRabbit |
| **Greptile** (aplikacja i CLI) | Chmura dostawcy; CLI lokalnie | PR; `greptile review` | `--instructions` | Niezweryfikowany | README npm `greptile` 3.6.0 |
| **Alibaba Open Code Review (`ocr`)** | Twój terminal lub runner, twój model | Uruchamiasz sam | Szablony reguł | Tokeny twojego modelu | README na GitHubie, npm 1.12.9 |
| **Graphite Agent** (dawniej Diamond, własność Cursora) | Chmura Graphite | PR | Konfiguracja dostawcy | Niezweryfikowany | **Wtórne** |

Trzy różnice ważą więcej niż listy funkcji:

- **Kto płaci i jak.** Boty zarządzane rozliczają się za review albo za stanowisko; ścieżki przez CLI i Actions zużywają tokeny z klucza, który już masz. Ceny tokenów są w [przewodniku po modelach](/pl/ecosystem/models/), nie tutaj.
- **Czy bot może zablokować merge.** Review z Claude Code Review „never approves or blocks the pull request”, a jego check run nigdy nie kończy się porażką (dokumentacja Claude Code, przeczytana 2026-10-16). Copilot domyślnie zostawia review typu „Comment”, które nie liczy się do wymaganych zatwierdzeń; zatwierdzić pull request może dopiero po włączeniu zatwierdzeń przez Copilota (public preview). Bramkę budujesz sam na podstawie wyniku bota: wymagaj rozwiązania rozmów na gałęzi albo odczytaj liczbę uwag według priorytetu w CI, jak pokazano niżej.
- **Skąd bot bierze reguły.** Każdy ma własny plik. Reguła w `.cursor/rules` nigdy nie trafia do Bugbota, a reguła w `REVIEW.md` nigdy nie trafia do lokalnego `/code-review`.

## Jak działa warstwowe AI code review?

Bot oparty na tym samym modelu, który napisał kod, ma te same martwe pola. Warstwy działają, bo każda wyłapuje inną klasę problemów po innej cenie, a każda kolejna jest droższa od poprzedniej. Konfigurację w konkretnych narzędziach opisują strony [code review z Codex](/pl/codex/ship/code-review/) i [automatyczne przeglądy kodu w Claude Code](/pl/claude-code/ship/review-automation/), a zespołowy kontrakt review ze skupionymi przebiegami na poprawność, bezpieczeństwo, testy i zgodność ze specyfikacją opisuje [zarządzanie warstwowym review pull requestów](/pl/developer-scorecard-guide/layered-pr-review/).

1. **Samodzielne review lokalnie, przed pushem.** Uruchom review wbudowane w narzędzie autora w świeżym kontekście: `/code-review` w Claude Code, `codex review --uncommitted` w Codeksie albo agenta Cursora z pierwszym promptem poniżej. Zajmuje od kilku sekund do kilku minut, mieści się w zwykłym limicie użycia i usuwa oczywiste błędy, zanim ktokolwiek je zobaczy.

2. **Drugi model, nadal lokalnie.** Poproś model innego dostawcy o krytyczny, adwersarialny przegląd: `/codex:review` lub `/codex:adversarial-review` z Claude Code, `greptile review`, `coderabbit review --agent` albo `ocr review`. Model z innej rodziny nie zgadza się z autorem z własnych powodów i właśnie o to chodzi.

3. **Bot na pull requeście, raz na PR.** Jeden bot odpowiada za pull request: Claude Code Review, workflow z `claude-code-action`, `@codex review`, Copilot code review albo Bugbot. Publikuje komentarze w liniach z priorytetem, a CI czyta jego wynik i decyduje, czy merge jest zablokowany. Review przy każdym pushu włączaj tylko dla pull requestów wysokiego ryzyka, bo mnoży koszt.

4. **Człowiek, tylko w klasach eskalacji.** Wskazana osoba czyta kod dotyczący uwierzytelniania, płatności, migracji i wszystkiego z twojej listy eskalacji, a resztę zatwierdza na podstawie dowodów. Listę eskalacji i werdykty opisuje [code review PR-a agenta](/pl/workflows/ship/agent-pr-review/).

**Ile kosztuje warstwowe review jednego pull requesta.** Warstwy 1 i 2 działają na użyciu, za które już płacisz. Warstwa 3 to osobna pozycja w budżecie: przy średniej 15–25 USD, którą podało ogłoszenie premiery Claude Code Review (9 marca 2026), zespół, który merge'uje 200 pull requestów miesięcznie z jednym review każdy, wyda około 3000–5000 USD miesięcznie, a tryb „po każdym pushu” mnoży tę kwotę przez liczbę pushy na pull request. To rachunek na średniej podanej przez Anthropic, nie pomiar, więc po pierwszym miesiącu odczytaj średni koszt na repozytorium w ustawieniach administratora. Workflow z `claude-code-action` lub `codex-action` rozlicza tylko tokeny i minuty runnera, a model i effort wybierasz sam, więc to tańsza warstwa 3, jeśli możesz obejść się bez zarządzanego kroku weryfikacji.

## Skonfiguruj bota do code review pull requestów w każdym narzędziu

Proces jest ten sam we wszystkich narzędziach. Różni się podłączenie, więc wybierz zakładkę.

**Claude Code**

    **Zarządzane Code Review (Team i Enterprise).** Właściciel organizacji (rola Owner) włącza je w `claude.ai/admin-settings/claude-code`, instaluje aplikację Claude na GitHubie, wybiera repozytoria i wyzwalacz: raz po utworzeniu PR, po każdym pushu albo ręcznie (Manual). Aby sprawdzić konfigurację, otwórz testowy pull request; w ciągu kilku minut pojawi się check run o nazwie **Claude Code Review**. W repozytorium w trybie Manual skomentuj `@claude review`, żeby dostać jedno review, albo `@claude review always`, żeby zapisać pull request na review przy kolejnych pushach. Usługa nie jest dostępna dla organizacji z Zero Data Retention ani z konfiguracją HIPAA.

    **Własny workflow na dowolnym planie z kluczem API lub tokenem OAuth.** Ten workflow jest zaadaptowany z dokumentacji GitHub Actions od Anthropic (dodaliśmy `persist-credentials: false`). Zapisz go jako `.github/workflows/claude-code-review.yml`:

    ```yaml
    name: Code Review
    on:
      pull_request:
        types: [opened, synchronize, ready_for_review, reopened]
    jobs:
      review:
        runs-on: ubuntu-latest
        permissions:
          contents: read
          pull-requests: read
          issues: read
          id-token: write
        steps:
          - uses: actions/checkout@v7
            with:
              fetch-depth: 1
              persist-credentials: false
          - uses: anthropics/claude-code-action@v1
            with:
              anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
              plugin_marketplaces: "https://github.com/anthropics/claude-code.git"
              plugins: "code-review@claude-code-plugins"
              prompt: "/code-review:code-review --comment ${{ github.repository }}/pull/${{ github.event.pull_request.number }}"
              claude_args: '--allowedTools "mcp__github_inline_comment__create_inline_comment"'
    ```

    O tym, gdzie trafi review, decydują dwie linie. `--comment` publikuje komentarze w liniach pull requesta; bez tej flagi uwagi zostają w logu uruchomienia. Zostaw linię `claude_args`: akcja uruchamia serwer MCP do komentarzy w liniach tylko wtedy, gdy `--allowedTools` go wymienia. Workflow pomija drafty, zamknięte pull requesty i te, pod którymi Claude już skomentował. Zadanie startuje na `pull_request`, a nie na `pull_request_target`, więc w publicznych repozytoriach GitHub nie przekazuje `ANTHROPIC_API_KEY` do pull requestów z forków i forki nie dostają review. `persist-credentials: false` trzyma `GITHUB_TOKEN` poza `.git/config`, gdy agent pracuje na kodzie pull requesta. Aby uwierzytelnić się subskrypcją, uruchom lokalnie `claude setup-token` i przekaż token jako `claude_code_oauth_token`.

    **Warstwy lokalne.** `/code-review` przegląda twoją gałąź i niezacommitowane zmiany jako subagent w tle; `/code-review high` poszerza zakres, `low` zgłasza tylko najpewniejsze uwagi, `--fix` wprowadza poprawki, a `--comment` publikuje uwagi w pull requeście. Przed merge'em głęboki przegląd daje `claude ultrareview 482`, który sprawdza pull request 482 w chmurze, gdzie „every reported finding is independently reproduced and verified”; `--json` wypisuje surowy wynik.

**Codex**

    **Review lokalne (Codex CLI 0.157.1).** `codex review` przyjmuje albo jedną flagę celu, albo własne instrukcje, nigdy oba naraz. W 0.157.1 połączenie `--uncommitted`, `--base` lub `--commit` z promptem kończy się błędem już przy parsowaniu argumentów: `the argument '--base <BRANCH>' cannot be used with '[PROMPT]'`:

    ```bash
    # Terminal, from the repository root (Codex CLI 0.157.1)
    codex review --uncommitted
    codex review --base main
    codex review --commit 3f9c2ab
    # No target flag: the instructions alone drive the review, so name the scope in them
    codex review "Review the changes on this branch against main. Focus on auth and SQL injection."
    ```

    `-` w miejscu promptu wczytuje ze standardowego wejścia **instrukcje**, nie diff, i obowiązuje go ta sama zasada: bez flagi celu. W CI `codex exec review` przyjmuje te same cele z tym samym ograniczeniem oraz `--json`, `--output-schema FILE` i `-o FILE`, który zapisuje końcową wiadomość do pliku, a kolejny krok może ją opublikować albo sparsować:

    ```bash
    # CI step, after checking out the pull request with full history (Codex CLI 0.157.1)
    codex exec review --base origin/main -o review.md
    ```

    **Własny workflow.** `openai/codex-action@v1` instaluje CLI i uruchamia `codex exec` z twoim promptem; README akcji zawiera kompletny przykład review pull requesta, który publikuje końcową wiadomość jako komentarz. W zadaniu review ustaw `permission-profile: ":read-only"`; akcja nie wystartuje, jeśli ustawisz też `sandbox`, bo „the profile and legacy sandbox systems do not compose”. Od v1.13 (2026-10-05) linuksowy `drop-sudo` wymaga `setfacl` (pakiet `acl`) i obsługi ACL w `/run` (CHANGELOG `openai/codex-action`, sprawdzone 2026-10-12); zobacz [agenci headless w CI](/pl/ecosystem/agent-tools/headless-agents-ci/).

    **Na GitHubie (wtórne).** Dokumentacja OpenAI sprawdzona 2026-08-28 opisuje włączenie code review Codeksa dla repozytorium i komentarz `@codex review` (albo `@codex security review`) w pull requeście, z własnymi regułami w `AGENTS.md`. Zanim wdrożysz, sprawdź konfigurację ponownie na stronie OpenAI.

**Cursor**

    **Bugbot (wtórne).** Cursor opisuje Bugbota jako narzędzie, które przegląda „pull requests” i wykrywa „bugs, security issues, and code quality problems” (cursor.com, sprawdzone 2026-10-12). Według wyciągów ze stron pomocy Cursora podłączasz GitHub lub GitLab w integracjach panelu Cursora, włączasz Bugbota dla repozytorium, a on robi review przy każdym otwarciu i aktualizacji pull requesta. Dokumentacja Cursora mówi teraz, że Bugbota konfiguruje się w Automations (sprawdzone 2026-10-12), więc te kroki mogą nie odpowiadać obecnej konfiguracji; kieruj się stroną Bugbota w Cursorze. Skomentuj `bugbot run`, żeby uruchomić go ponownie. Reguły projektu dla Bugbota trafiają do `.cursor/BUGBOT.md`; pliki `.cursor/rules/*.mdc` go nie dotyczą (według dokumentacji Cursora reguły nie obowiązują w przeglądach PR przez Bugbota, sprawdzone 2026-10-12). Cursor przeniósł Bugbota z subskrypcji 40 USD za miejsce na rozliczanie według zużycia w planach Teams i indywidualnych (blog Cursora, 2026-05-11); poziomy effort (Low, Default, High, Smart) istnieją tylko w planach Bugbota rozliczanych według zużycia, `@cursor remember [fact]` w PR uczy go reguły, a Autofix uruchamia Cloud Agent, który naprawia to, co wykazał przegląd (dokumentacja Cursora, sprawdzone 2026-10-12). W planach Teams i Enterprise changelog Cursora z 2026-09-23 wymienia też Security Review, który publikuje jeden komentarz na pull request z raportem o podatnych na wykorzystanie błędach, oraz Rollouts, który monitoruje każdy pull request od review do produkcji; ta strona ich nie porównuje, a o własnych botach Cursora mówi [code review w Cursorze](/pl/cursor-ide/ship/code-review/).

    **Drugi model z Cursora.** W Cursorze najszybszym drugim modelem jest nowy czat agenta na modelu innego dostawcy niż ten, który napisał zmianę, z adwersarialnym promptem poniżej. Jeśli chcesz recenzenta spoza Cursora, użyj CLI: `greptile skills install` zapisuje skille Greptile w `.agents/skills/`, które Cursor czyta, a `greptile review` działa w terminalu Cursora. `npx skills add coderabbitai/skills` w ten sam sposób instaluje skill do code review od CodeRabbit.

    **Graphite Agent (wtórne).** Recenzent AI od Graphite, dawniej nazywany Diamond, według doniesień należy do Cursora od grudnia 2025. Jego CLI do stacked PR to pakiet npm `@withgraphite/graphite-cli` (1.8.6); pakiet `@graphite/cli` nie istnieje.

### Dostrój Claude Code Review plikiem `REVIEW.md`

`REVIEW.md` leży w katalogu głównym repozytorium i trafia do każdego agenta, który szuka i weryfikuje uwagi, więc reguła zapisana tam działa pewniej niż ta sama reguła w długim `CLAUDE.md`. Anthropic wymienia siedem wzorców; najwięcej szumu usuwają cztery z nich: nowa definicja Important, limit nitów, reguły pomijania i sprawdzenia specyficzne dla repozytorium, a do tego reguła ponownego review, dzięki której pull request zbiega się, zamiast zbierać nowe nity przy każdym pushu. Ta wersja, zaadaptowana z przykładu Anthropic, nadaje się na pierwszy commit:

```markdown
# Review instructions

## What Important means here
Reserve Important for findings that would break behavior, leak data,
or block a rollback: incorrect logic, unscoped database queries, PII in
logs or error messages, and migrations that aren't backward compatible.
Style, naming and refactoring suggestions are Nit at most.

## Cap the nits
Report at most five Nits per review. If you found more, say "plus N
similar items" in the summary. After the first review of a PR, post
Important findings only.

## Do not report
- Anything CI already enforces: lint, formatting, type errors
- Generated files under `src/gen/` and any `*.lock` file

## Always check
- New API routes have an integration test
- Log lines don't include email addresses, user IDs or request bodies
- Database queries are scoped to the caller's tenant
```

Pisz krótko. Anthropic ostrzega, że „a long `REVIEW.md` dilutes the rules that matter most”. Usługa czyta `REVIEW.md` z gałęzi bazowej lub domyślnej, nigdy ze zmian samego pull requesta, więc zmiana tego pliku działa dopiero po scaleniu (dokumentacja Claude Code, przeczytana 2026-10-16).

### Zamień neutralny check run w bramkę przed merge'em

Ostatnia linia szczegółów check runu **Claude Code Review** to liczba uwag według priorytetu w formacie do odczytu maszynowego. Według ogłoszenia premiery Anthropic (9 marca 2026) średnie review Code Review trwa około 20 minut, więc bramka musi poczekać na wynik, a nie sprawdzić go raz. Ten workflow uruchamia się po zakończeniu check runu i publikuje status na przejrzanym commicie: `success`, gdy liczba uwag Important wynosi zero, w przeciwnym razie `failure`. Zapisz go jako `.github/workflows/claude-review-gate.yml` na gałęzi domyślnej:

```yaml
name: Claude review gate
on:
  check_run:
    types: [completed]
permissions:
  checks: read
  statuses: write
jobs:
  gate:
    if: github.event.check_run.name == 'Claude Code Review'
    runs-on: ubuntu-latest
    steps:
      - name: Turn the severity count into a commit status
        env:
          GH_TOKEN: ${{ github.token }}
          REPO: ${{ github.repository }}
          RUN_ID: ${{ github.event.check_run.id }}
          SHA: ${{ github.event.check_run.head_sha }}
        run: |
          # The severity line is JSON like {"normal": 2, "nit": 1, "pre_existing": 0}; "normal" = Important
          important=$(gh api "repos/$REPO/check-runs/$RUN_ID" \
            --jq '.output.text | split("bughunter-severity: ")[1] | split(" -->")[0] | fromjson | .normal') || important=""
          if [ "$important" = "0" ]; then state=success; desc="No Important findings"
          else state=failure; desc="Important findings: ${important:-unknown}"; fi
          gh api "repos/$REPO/statuses/$SHA" -f state="$state" \
            -f context="claude-review-gate" -f description="$desc"
```

Żeby bramkować według wątków, wymagaj na gałęzi rozwiązania rozmów: rozwiązanie wątku zamyka znalezisko, a sama odpowiedź nie (dokumentacja Claude Code, przeczytana 2026-10-16). Żeby bramkować według liczby, oznacz `claude-review-gate` jako wymagany status check w ochronie gałęzi albo w rulesecie; check, który kończy się błędem, ale nie jest wymagany, niczego nie blokuje. Workflow publikuje status commita, zamiast polegać na wyniku własnego zadania, bo według dokumentacji GitHuba workflow uruchomiony przez `check_run` działa na gałęzi domyślnej, więc jego zadanie nie pojawia się w pull requeście. Dopóki status nie dotrze, wymagany check jest oczekiwany, a merge pozostaje zablokowany, co obejmuje też review, które jeszcze trwa. W repozytorium w trybie Manual nic nie zostanie opublikowane, dopóki ktoś nie skomentuje `@claude review`.

Status należy do jednego commita i nie przechodzi na kolejne. Jeśli autor wypchnie zmiany po review, bramka na nowym commicie pozostaje oczekująca, a merge zablokowany, dopóki ten commit nie zostanie zrecenzowany. Tak ma być, bo niezrecenzowany commit nie powinien trafić do gałęzi głównej, ale zaplanuj to: przed merge skomentuj `@claude review` na ostatnim commicie albo w pull requestach, które zmieniają się po review, użyj `@claude review always` (albo wyzwalacza review przy każdym pushu w repozytorium). Uwzględnij dodatkowe przebiegi w budżecie, bo każde review jest rozliczane.

W Greptile `greptile review status` kończy się kodem `0`, gdy commit ma ukończone review, `3`, gdy review trwa, `4` lub `5` przy review nieudanym albo anulowanym oraz `1`, gdy review nie ma albo nie jesteś zalogowany. Dzięki temu hook pre-push albo krok CI może wymagać ukończonego review przed merge'em. Każdy kod inny niż `0` traktuj jako „brak review”.

## Dodaj drugi model: Greptile, CodeRabbit, ocr i plugin Codeksa

Każde z tych narzędzi daje recenzenta spoza twojego narzędzia autora. Polecenia instalacji sprawdziliśmy 2026-09-26 w README lub wpisie npm każdego projektu; wyjątkiem jest strona instalatora CodeRabbit, która jest źródłem wtórnym.

**Plugin Codeksa dla Claude Code** (OpenAI, `openai/codex-plugin-cc`). Uruchamia twoją lokalną instalację Codeksa z sesji Claude Code i zużywa limity Codeksa. `/codex:review` to „a normal read-only Codex review” i nie przyjmuje tekstu z kierunkiem przeglądu; `/codex:adversarial-review` można sterować i kwestionuje on projekt rozwiązania.

```text
# Inside Claude Code
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup
/codex:adversarial-review --base main challenge whether this retry design is safe under concurrent writes
```

`/codex:setup --enable-review-gate` dodaje hook `Stop`, który po każdej odpowiedzi Claude'a uruchamia review Codeksa i blokuje zakończenie, jeśli znajdzie problemy. README ostrzega, że ta bramka „can create a long-running Claude/Codex loop and may drain usage limits quickly”, więc włączaj ją tylko w sesji, którą obserwujesz.

**Greptile CLI** (npm `greptile` 3.6.0, Node 22 lub nowszy). `greptile review` porównuje merge base z `HEAD`; `--plus` i `--apex` podnoszą effort.

```bash
npm install -g greptile          # or: brew install greptileai/tap/greptile
greptile                         # signs you in on first run
greptile init                    # admin only: enables the repository
greptile review -b main --instructions "focus on retry cancellation"
```

**CodeRabbit CLI.** Instaluj go oficjalnym instalatorem CodeRabbit albo przez Homebrew, nie z npm. Plik SKILL.md w repozytorium `coderabbitai/skills` samego CodeRabbit wskazuje `https://www.coderabbit.ai/cli`. Polecenia instalacji poniżej są **wtórne**: pochodzą z wyciągów z dokumentacji CodeRabbit, a strony instalatora nie czytaliśmy ponownie 2026-09-26. Nie instaluj nazwy z npm: pakiet npm `coderabbit` to „security holding package” (wersja `0.0.1-security.1`). `--agent` zwraca uwagi, na których agent może działać, z priorytetami od critical do info.

```bash
curl -fsSL https://cli.coderabbit.ai/install.sh | sh   # or: brew install --cask coderabbit (secondary)
coderabbit auth login
coderabbit review --agent --uncommitted
coderabbit review --agent --base main
```

**Alibaba Open Code Review (`ocr`)**, Apache-2.0, npm `@alibaba-group/open-code-review` 1.12.9. Łączy deterministyczny wybór plików i dopasowanie reguł z agentem LLM i działa z każdym endpointem zgodnym z OpenAI lub Anthropic, więc kod nie opuszcza dostawcy, z którego już korzystasz.

```bash
npm install -g @alibaba-group/open-code-review
ocr config provider && ocr config model
ocr review --from main --to feature-branch --format json --output result.json
```

README Alibaby podaje wyższą precyzję i F1 niż Claude Code na tym samym modelu, przy około jednej dziewiątej tokenów, i przyznaje niższy recall: „a deliberate trade-off favoring precision over noise”. To benchmark dostawcy (200 pull requestów z 50 repozytoriów), którego tu nie odtwarzaliśmy. Wybierz `ocr` do warstwy w CI, w której szum kosztuje cię więcej niż przeoczony nit.

Stan na 2026-09-26: `anthropics/claude-code-action` miał 8951 gwiazdek na GitHubie, `openai/codex-action` 1248, `openai/codex-plugin-cc` 33 594, a `alibaba/open-code-review` 41 400; w katalogu pluginów Anthropic `greptile` miał 56 611 instalacji, a `coderabbit` 32 361 (GitHub i claude.com/plugins, odczyt do katalogu ekosystemu tej witryny). Gwiazdki mierzą zainteresowanie, nie jakość review. Oba pluginy są w oficjalnym marketplace Anthropic (`claude-plugins-official`, sprawdzone 2026-09-26):

```text
# Inside Claude Code
/plugin install greptile@claude-plugins-official
/plugin install coderabbit@claude-plugins-official
```

Pluginy mają koszt kontekstu w każdej sesji. Zanim któryś zostawisz, uruchom w terminalu `claude plugin details greptile` albo `claude plugin details coderabbit`, które pokazuje komponenty pluginu i szacowany koszt w tokenach, i porównaj `/context` przed i po.

## Prompty do skopiowania do warstwowego AI code review

**Prompt do skopiowania: samodzielne review przed pushem**

```text
Review the changes on this branch against main as if a different engineer
wrote them. Start a fresh read: do not rely on anything you remember from
writing this code.

Report only findings that could break behavior in production: wrong logic,
unhandled errors on external calls, missing authorization or tenant scoping,
data loss, race conditions, and tests that assert nothing. No style, naming
or refactoring comments.

For each finding give: file:line, severity (Important or Nit), the input or
state that triggers it, and the smallest fix. If you are not confident, say
so and give the command that would confirm it. End with "No Important
findings" if that is the case. Do not edit any file.
```

**Prompt do skopiowania: adwersarialne review drugim modelem**

```text
You are reviewing a change another AI model wrote and already reviewed.
Assume its review missed something. Read the diff against main and:

1. List the three assumptions the change depends on that are not checked
   by any test, with file:line.
2. For each, describe the concrete input, timing or failure that breaks it.
3. Name the test that would catch it, in one sentence.

Ignore anything a linter, formatter or type checker already enforces.
Do not repeat findings that are about style. If you find nothing that could
break production, say "No production-relevant findings" and stop.
```

**Prompt do skopiowania: segregacja komentarzy botów, zanim przeczyta je człowiek**

```text
Collect every unresolved review comment on this pull request from review
bots (Claude, Codex, Bugbot, CodeRabbit, Greptile). For each comment:

- Classify it: REAL BUG, ALREADY FIXED, DUPLICATE, FALSE POSITIVE or STYLE.
- For REAL BUG, write a failing test that proves it first, then fix it.
- For FALSE POSITIVE, quote the code that shows why, in one sentence.

Do not resolve or delete any comment. Post one summary comment with the
counts per class and the commit SHA the tests ran on.
```

Trzeci prompt daje liczby potrzebne do metryki precyzji poniżej. W Claude Code z zainstalowanym GitHub CLI agent czyta komentarze przez `gh api`; w Codeksie i Cursorze użyj serwera GitHub MCP albo `gh` w terminalu.

## Jak udowodnić, że bot do code review jest wart swojej ceny?

Bot do code review sam jest niezweryfikowanym agentem, dopóki go nie zmierzysz. Śledź cztery liczby dla każdego bota co miesiąc i omawiaj je z zespołem:

| Metryka | Definicja | Reaguj, gdy |
| ------- | --------- | ----------- |
| **Precyzja** | Uwagi, które doprowadziły do zmiany w kodzie, podzielone przez wszystkie zgłoszone uwagi | Spada poniżej poziomu, przy którym ludzie jeszcze czytają komentarze; zaostrz `REVIEW.md` lub `BUGBOT.md` albo obniż effort |
| **Ucieczki** | Defekty na produkcji w kodzie przejrzanym przez bota, przy których wystarczyłby jeden jego komentarz | Rosną; dopisz przeoczoną klasę do listy „Always check” bota |
| **Koszt na zmerge'owany PR** | Miesięczne wydatki na bota podzielone przez liczbę zmerge'owanych pull requestów | Rośnie szybciej niż liczba PR; przełącz bota z „po każdym pushu” na „raz na PR” albo Manual |
| **Czas do pierwszego review** | Minuty od otwarcia PR do pierwszego komentarza bota | Przekracza twoje SLA na review; według ogłoszenia premiery Anthropic (9 marca 2026) Claude Code Review trwa średnio około 20 minut, więc nie każ ludziom na nie czekać |

Boty nigdy nie podejmują decyzji. CI odpowiada za bramkę (testy, typy, lint, sprawdzenie liczby uwag powyżej), bot za komentarze, a osoba zatwierdzająca, wskazana w pull requeście, za merge. Właściciele kodu z `CODEOWNERS` zatwierdzają klasy eskalacji niezależnie od tego, co powiedziały boty. Kanoniczne definicje metryk zespołu opisuje strona [metryki inżynierii agentowej: ramy pomiaru](/pl/org/metrics-frameworks/).

**Pułapki, przez które boty do code review się mylą**

- **`/code-review` to nie Code Review.** Polecenie lokalne działa na każdym planie i nie czyta `REVIEW.md`; zarządzana usługa na pull requestach jest tylko dla Team i Enterprise i czyta zarówno `REVIEW.md`, jak i `CLAUDE.md`.
- **`/review` w Claude Code** to od v2.1.223 alias `/code-review`, a nie dawne jednoprzebiegowe review pull requesta.
- **`@claude review` jest ignorowane**, gdy twoje członkostwo w organizacji jest prywatne, a nie jesteś bezpośrednim współpracownikiem repozytorium. Upublicznij członkostwo albo poproś administratora o dodanie cię.
- **`npm i coderabbit`** instaluje pakiet-zaślepkę bezpieczeństwa. **`npm i @graphite/cli`** nie istnieje; CLI to `@withgraphite/graphite-cli`.
- **Bugbot nie czyta `.cursor/rules`** (dokumentacja Cursora, sprawdzone 2026-10-12); czyta `.cursor/BUGBOT.md` (wtórne).
- **`/codex:review` ignoruje tekst z kierunkiem przeglądu.** Gdy chcesz sterować review, użyj `/codex:adversarial-review`.
- **Ultrareview nie jest dostępne** na Amazon Bedrock, Agent Platform w Google Cloud (dawniej Vertex AI) i Microsoft Foundry ani przy Zero Data Retention; `/code-review ultra` uruchamia wtedy zamiast niego review lokalne w twojej sesji.

## Skąd wiesz, że recenzent się poprawił, a nie tylko zmienił?

Cztery metryki powyżej to miesięczny dashboard, a pull requesty z następnego miesiąca będą inne niż z tego. Żeby wiedzieć, czy zmiana promptów, narzędzi, modelu albo `REVIEW.md` recenzenta pomogła, uruchamiaj ponownie stały zestaw przypadków. Zespół Claude Code opisuje swój w artykule „How the Claude Code team does code review” (Addy Osmani, Morgan Westlee Lunt i Qing Wang, blog inżynierski Anthropic, 15 października 2026): dawne pull requesty, które wywołały incydenty, razem z poprawkami do przodu (fix-forward) i rewertami, a każdy błąd i miejsce, w którym tkwił, potwierdzili inżynierowie znający ten kod. Recenzent przechodzi ten zestaw codziennie, każda jego zmiana jest oceniana na całości zestawu, a zestaw rośnie z każdym incydentem. Artykuł nie mówi, jak odtwarza się przypadek, więc poniższe kroki to jeden ze sposobów.

1. **Zbierz przypadki** z narzędzia do śledzenia incydentów i z rewertów. Tytuły rewertów mają zastrzeżenie ze [strony o kolejce code review](/pl/teams/review-queue/#jak-mierzyć-czas-ludzi-w-review-z-rewertami-jako-zabezpieczeniem):

    ```bash
    # Terminal, inside the repository, gh authenticated
    gh pr list --state merged --limit 200 \
      --json number,title \
      --jq '.[] | select(.title | startswith("Revert")) | [.number, .title] | @tsv'
    ```

2. **Poproś kogoś, kto zna kod, o potwierdzenie każdego przypadku:** commit lub zakres, który wprowadził błąd, plik i linie, jedno zdanie o tym, co się psuje, i kto to potwierdził. Przypadek, którego nikt nie potwierdził, sprawdza recenzenta względem twojego domysłu.

3. **Zapisz przypadki obok konfiguracji recenzenta** (kolumny rozdziela tabulator, wiersz jest ilustracją):

    ```text title="evals/reviewer/cases.tsv"
    case	review_range	bug_location	bug	confirmed_by
    inc-0412	9c1e7a2^..9c1e7a2	src/refund.ts:88	Retry lacks idempotency key	@anna
    ```

4. **Odtwórz każdy przypadek na checkoucie kodu z tamtego czasu.** Recenzent, który czyta pliki wokół diffa, zobaczyłby dzisiejszy kod z błędem już naprawionym, a czułość wyszłaby zawyżona. Użyj tymczasowego worktree na ostatnim commicie zakresu, uruchom recenzenta z niego i zapisuj każdy wynik w głównym checkoucie jako `evals/reviewer/runs/RUN_ID/CASE.md` (`RUN_ID` to nazwa przebiegu, `CASE` nazwa przypadku), żeby worktree został czysty i `git worktree remove` mogło go usunąć:

    ```bash
    # Terminal, main checkout: detached worktree at the end commit
    git worktree add --detach ../eval-inc-0412 9c1e7a2
    # run the reviewer from there; write its output to the main checkout
    git worktree remove ../eval-inc-0412
    ```

    Uruchom recenzenta z tego worktree:

    - **`/code-review` w Claude Code:** uruchom sesję w worktree i wpisz `/code-review 9c1e7a2^..9c1e7a2`. Czyta `CLAUDE.md`, a nie `REVIEW.md`, więc nie zastępuje usługi zarządzanej.
    - **`codex review`:** uruchom `codex review --commit 9c1e7a2` (Codex CLI 0.157.1).
    - **Bot hostowany, na przykład Claude Code Review lub Bugbot:** wypchnij commit rodzica i ostatni commit przypadku jako dwie robocze gałęzie i otwórz pull request z drugiej do pierwszej, żeby bot widział kod z tamtego commita. Potem poproś o review przez `@claude review` albo `bugbot run` (źródło wtórne).

    Odtworzenie przez bota hostowanego jest rozliczane jak zwykłe review. Anthropic uruchamia swój zestaw codziennie; swój uruchamiaj raz w tygodniu, dopóki nie znasz kosztu.

5. **Policz czułość i zlicz resztę.** Przypadek jest znaleziony, gdy recenzent opublikuje w miejscu błędu znalezisko, które go opisuje. Czułość (recall) to liczba znalezionych przypadków podzielona przez wszystkie, a każde inne znalezisko trafia do zliczenia szumu poniżej. Ocenę robi pierwszy prompt poniżej.

6. **Oceń ponownie po każdej zmianie** promptu, narzędzia, modelu, poziomu albo pliku z regułami. Usługa nigdy nie czyta `REVIEW.md` ze zmian samego pull requesta (dokumentacja Claude Code, przeczytana 2026-10-16), więc zmiana tego pliku działa dopiero po scaleniu do gałęzi bazowej lub domyślnej i wtedy oceniasz ponownie. Zmiana, która podnosi czułość i szum naraz, nie jest jeszcze poprawą.

**Prompt do skopiowania: oceń przebieg recenzenta względem zestawu ewaluacyjnego**

```text
Read evals/reviewer/cases.tsv and the reviewer outputs in
evals/reviewer/runs/RUN_ID/ (one file per case, named after the case).

For each case:
1. Mark FOUND if the output has a finding at the case's bug_location (same
   file, within 10 lines) that describes the same bug. Quote that finding.
   Otherwise mark MISSED.
2. List every other finding in that file as an extra, with file:line and one
   line on what it claims.

Do not judge whether an extra is a real bug. Print a table: case, FOUND or
MISSED, number of extras. Then print recall (FOUND divided by all cases) and
the total number of extras. If evals/reviewer/runs/PREVIOUS_RUN_ID/ exists,
list every case that was FOUND there and is MISSED now. Do not edit any file.
```

Zastąp `RUN_ID` nazwą folderu tego przebiegu, a `PREVIOUS_RUN_ID` nazwą folderu poprzedniego.

## Jak zmierzyć szum recenzenta?

Recenzent może podnieść czułość, zgłaszając więcej wszystkiego. Mówi o tym artykuł: „It's easy to catch more bugs if you don't mind flagging a lot of non-bugs, so we need a check on that.” Anthropic sortuje każdy komentarz według reakcji osoby w pull requeście (poprawiła go, powiedziała, że jest błędny, powiedziała, że zachowanie jest zamierzone, albo uznała, że nie ma to znaczenia) i uruchamia recenzenta na pull requestach znanych jako czyste, licząc zgłoszenia, które skłoniłyby kogoś do szkodliwej zmiany.

Artykuł nie mówi, jak zapisuje się te reakcje. Jedna tania konwencja to zaczynanie każdej odpowiedzi od `fixed:`, `wrong:`, `intentional:` albo `minor:`; zlicza je prompt poniżej. Każda reakcja wskazuje inną dźwignię:

| Co zrobił autor | Co to mówi | Co zmienić |
| --------------- | ---------- | ---------- |
| Poprawił | Przydatne znalezisko; odsetek poprawionych to metryka precyzji powyżej | Zostaw regułę, która je wytworzyła |
| Uznał, że to błąd | Fałszywy alarm | Wymagaj cytatu `file:line` dla tej klasy znalezisk albo dodaj regułę pomijania |
| Uznał, że to zamierzone | Recenzentowi zabrakło kontekstu | Dopisz kontekst do `CLAUDE.md` albo pliku z regułami |
| Uznał, że to bez znaczenia | Prawda, ale niewarta rundy | Ogranicz nity i podnieś poprzeczkę dla Important |

Do zestawu czystych użyj zmergowanych pull requestów, których nikt potem nie cofnął, nie poprawiał kolejnym commitem ani nie powiązał z incydentem, odtwórz je tak samo, z checkoutu na head każdego pull requesta, i policz zgłoszenia, które skłoniłyby do szkodliwej zmiany. Wynik czułości tego kosztu nie pokazuje.

Anthropic zapisuje swój priorytet wprost: najpierw prawdziwe błędy, potem mniej rund review. Zapisz własny tak samo: zmiana, która skraca rundy kosztem pominięcia znanych błędów, nie przechodzi wtedy ewaluacji, a zmiana, która znajduje więcej kosztem większej liczby rund, to kompromis wybrany świadomie.

To, jak często recenzent się odzywa, to inna sprawa niż to, jak często ma rację. Gdy Anthropic uruchomił Code Review jako research preview, odsetek jego wewnętrznych pull requestów z merytorycznymi komentarzami review wzrósł z 16% do 54% (ogłoszenie premiery Anthropic z 9 marca 2026, powtórzone w artykule z 2026-10-15). Artykuł dodaje, że większość pull requestów powyżej 1000 linii dostaje znaleziska, a większość małych wraca czysta. To liczba o pokryciu, dotycząca własnych pull requestów Anthropic, więc czytaj ją obok miar szumu.

Szum kosztuje więcej, gdy autorem jest agent. Człowiek odpuszcza nita w kilka sekund, a agent go poprawia, czyli robi kolejny commit i wywołuje kolejną rundę review. Dlatego reguły `REVIEW.md`, które ograniczają nity i po pierwszym review każą publikować tylko znaleziska Important, mają największe znaczenie w pull requestach pisanych przez agentów; resztę opisuje [limit rund](/pl/workflows/ship/agent-pr-review/#dlaczego-pętla-review-agenta-potrzebuje-limitu-rund).

**Prompt do skopiowania: zlicz, co autorzy zrobili z komentarzem każdego bota**

```text
With gh api or the GitHub MCP server, list every review comment that a bot
(Claude, Codex, Bugbot, CodeRabbit or Greptile) posted on pull requests merged
in the last 30 days. For each comment, read its thread and sort it by the
author's response:
- FIXED: the author pushed a change for it, or replied "fixed:".
- WRONG: the author replied "wrong:", or showed the finding is incorrect.
- INTENTIONAL: the author replied "intentional:".
- MINOR: the author replied "minor:".
- UNANSWERED: no reply, or the thread was resolved with no reply and no change.

Print one table per bot with the count for each response and the share of
FIXED among all comments. Quote one WRONG and one INTENTIONAL example per bot.
Do not edit, reply to or resolve any thread.
```

## Jak weryfikacja przez głosowanie zmniejsza szum recenzenta?

W artykule kilku agentów szuka błędów jednocześnie, potem osobna grupa głosuje nad każdym znaleziskiem, a znalezisko jest publikowane tylko wtedy, gdy dość agentów uzna je za prawdziwe. Znaleziska dotyczące wyłącznie stylu, diagnostyki albo porządków są odrzucane, a zespół przetestował te filtry w teście A/B na własnych pull requestach, zanim je zostawił. To, co zostaje, trafia do komentarzy w linii oznaczonych jako Important, Nit albo Pre-existing, „so a bug the PR didn't introduce doesn't look like the author's fault”. Dokumentacja Claude Code opisuje usługę publiczną jako find, verify, rank i post, gdzie etap verify odsiewa fałszywe alarmy (przeczytane 2026-10-16); szczegół z głosowaniem pochodzi z artykułu. Jeśli prowadzisz własnego recenzenta jako subagenta albo skill, skopiuj ten kształt:

1. **Rozdziel szukającego od weryfikatora.** Weryfikator widzi jedno znalezisko i kod, na który wskazuje, bez rozumowania szukającego, i próbuje je obalić.
2. **Publikuj tylko to, co przetrwa:** większość z kilku weryfikatorów albo `file:line` jednego weryfikatora jako dowód. Odrzucaj znaleziska dotyczące wyłącznie stylu, diagnostyki albo porządków, chyba że styl ukrywa błąd.
3. **Każdy filtr sprawdź testem A/B na zestawie ewaluacyjnym, zanim go zostawisz.** Czułość nie może spaść, a szum musi.

**Prompt do skopiowania: zweryfikuj znaleziska review, zanim ktokolwiek je przeczyta**

```text
Read review-findings.md. Each finding has a file:line and a claim. Treat every
finding as if you were a separate verifier that sees only that finding and the
code it points at, not the reviewer's reasoning. Use a fresh subagent or
session per finding if your tool supports it.

For each finding:
1. Try to refute it: find the code path, test or guard that makes the claim
   false, and quote file:line.
2. If you cannot refute it, reproduce it: name the input or state that
   triggers it and the command that would show it.
3. Vote KEEP or DROP. DROP any finding that is only about style, diagnostics
   or cleanup, unless it hides a bug.

Print a table: finding, vote, one-line reason. Do not edit any file and do not
post anything.
```

## Jak wdrożyć recenzenta i go dostroić?

Rada z artykułu: dodaj recenzenta AI w jednym repozytorium, dostrajaj go przez kilka tygodni, a potem rozszerzaj:

1. **Zacznij od jednego repozytorium**, w którym pull requesty są częste, a przeoczony błąd ma swoją cenę. Dla Claude Code Review strona o kosztach radzi mały pilotaż z miesięcznym limitem wydatków i ustawieniem **Review runs** na **Once after PR creation** albo **Manual**, a potem odczytanie średniego kosztu review dla każdego repozytorium (dokumentacja Claude Code, przeczytana 2026-10-16).

2. **Napisz plik z regułami krótko.** Dobre pliki `REVIEW.md` z artykułu mówią, jak wygląda porażka w danym repozytorium (dla dokumentacji „it lies”, dla konfiguracji „it misroutes”), ograniczają nity, wymieniają ścieżki do pominięcia, proszą o plik i linię jako dowód zamiast domysłu z nazwy oraz o podsumowanie zaczynające się od liczby, które wprost mówi, gdy nie ma nic do poprawienia. Te same cechy pasują do `AGENTS.md` dla `@codex review` i `.cursor/BUGBOT.md` dla Bugbota. Ewaluacja powyżej sprawdza, czy recenzent trzyma się tego pliku.

3. **Dopasuj poziom do kosztu przeoczenia.** Claude Code Review ma poziomy Quick, Standard i Deep, które Owner ustawia dla organizacji, z możliwością zmiany dla repozytorium. Artykuł mówi: „Deep is worth it where one missed bug costs more than the extra review time”. Bugbot ma poziomy effort (Low, Default, High, Smart) w planach rozliczanych według zużycia, jak zapisano w zakładce Cursor powyżej.

4. **Co tydzień naprawiaj powtórzenia u źródła:** w skillu, regułą lintera albo w plikach z instrukcjami. Gdy recenzent coś przeoczy, zapytaj, czego nie miał przed sobą, i wpisz to do `CLAUDE.md`, skilla albo nowego sprawdzenia. Potem oceń ponownie zestaw ewaluacyjny i przeczytaj tabelę reakcji.

5. **Rozszerzaj po kilku tygodniach**, zaczynając następne repozytorium od pliku z regułami i przypadków ewaluacji pierwszego.

## Co się psuje, gdy uruchamiasz boty do AI code review?

**Bot zasypuje prawdziwy błąd nitami.** Trzydzieści komentarzy, jeden ważny, i zespół przestaje czytać. Jak wyjść: ogranicz nity w `REVIEW.md` lub `BUGBOT.md`, dopisz „after the first review, post Important findings only” i śledź precyzję. Jeśli precyzja dalej spada, przełącz tego bota na Manual.

**Dwa boty kłócą się pod jednym pull requestem.** Claude Code Review i Bugbot komentują, nie zgadzają się, a autor poprawia jedno i otwiera drugie. Jak wyjść: warstwa 3 ma jednego właściciela. Drugi model uruchamiaj lokalnie (warstwa 2), gdzie jego wynik trafia do autora, a nie do pull requesta.

**Review przy każdym pushu mnoży rachunek.** Pull request z 12 pushami dostaje 12 review. Jak wyjść: używaj trybu „raz po utworzeniu PR” albo Manual i proś o `@claude review always` tylko przy pull requestach wysokiego ryzyka. Ustaw miesięczny limit wydatków na Claude Code Review w `claude.ai/admin-settings/usage`.

**Forki i drafty nie dostają review i nikt tego nie zauważa.** GitHub nie przekazuje sekretów do pull requestów z forków, `claude-code-action` pomija drafty, a Code Review przegląda forki tylko po komentarzu z poleceniem. Jak wyjść: nie traktuj zadania review jako wymaganego checka, bo GitHub liczy pominięte zadanie jako zaliczone. Zamiast tego wymagaj opisanego wyżej statusu `claude-review-gate`: pozostaje w stanie oczekiwania i blokuje merge, dopóki ostatni commit nie ma review. Przed zatwierdzeniem pull requesta z forka niech maintainer skomentuje `@claude review`.

**Zespół traktuje czysty przebieg bota jak akceptację.** „Bot nic nie znalazł” staje się powodem merge'a. Jak wyjść: bramką są testy i liczba uwag według priorytetu, zatwierdzenia przez Copilota zostaw wyłączone, chyba że człowiek nadal zatwierdza klasy eskalacji, a każdy pull request ma wskazaną osobę zatwierdzającą.

**Zmiana podnosi czułość i szum naraz.** Ewaluacja pokazuje więcej znalezionych znanych błędów i nikt nie policzył nadmiarowych znalezisk. Naprawa: przy każdym przebiegu oceniaj razem czułość i zliczenie szumu, a zmianę zostaw tylko wtedy, gdy zapisany priorytet pozwala na taki kompromis.

**Ewaluacja ocenia opinię recenzenta.** Przypadki, których nie potwierdził nikt znający kod, nagradzają to, co recenzent i tak mówi. Naprawa: każdy przypadek potwierdza osoba znająca ten kod, jak w zestawie Anthropic, a przypadek, którego nikt nie potwierdzi, usuń.

**Pętla review zjada limity.** Bramka review w pluginie Codeksa albo bot z autofixem wciąż znajduje i poprawia nowe problemy. Jak wyjść: włączaj bramkę tylko w obserwowanych sesjach, zatrzymaj się na limicie rund (trzy rundy w ustawieniu Anthropic, dwa zwroty na stronie o review PR-ów agentów) i eskaluj do człowieka z listą otwartych uwag. Dlaczego późniejsze rundy znajdują głównie stary kod, wyjaśnia sekcja [dlaczego pętla review agenta potrzebuje limitu rund](/pl/workflows/ship/agent-pr-review/#dlaczego-pętla-review-agenta-potrzebuje-limitu-rund).

## Dokąd dalej z AI code review

- [Code review PR-a agenta](/pl/workflows/ship/agent-pr-review/) — Sześciokrokowa ocena przez człowieka, która działa nad botami, z werdyktami, klasami eskalacji i limitem rund dla pętli review.
- [Pakiet dowodów](/pl/workflows/ship/evidence-bundle/) — Co pull request agenta musi udowodnić, zanim przeczyta go jakikolwiek recenzent, człowiek czy bot.
- [Bramki bezpieczeństwa dla kodu agentów](/pl/ecosystem/observability/agent-security-gates/) — Deterministyczne skanery (Semgrep, Gitleaks, Snyk Agent Scan), które działają obok botów do code review.
- [Kolejka code review](/pl/teams/review-queue/) — Budżety rozmiaru, ścieżki ryzyka i miara czasu ludzi z rewertami jako zabezpieczeniem.
- [Code review z Codex](/pl/codex/ship/code-review/) — Jeden standard review w Codex CLI, aplikacji desktopowej i na GitHubie.
- [Automatyczne przeglądy kodu w Claude Code](/pl/claude-code/ship/review-automation/) — Review z CLI w Claude Code: sprawdzenia przed commitem, analiza PR i bramki jakości.
- [Zarządzaj warstwowym review pull requestów](/pl/developer-scorecard-guide/layered-pr-review/) — Zespołowy kontrakt review ze skupionymi przebiegami na poprawność, bezpieczeństwo, testy i zgodność ze specyfikacją.
- [Codex GitHub Action](/pl/codex/ship/ci-cd/) — Codex we własnym CI z profilami uprawnień.
- [Ceny i domyślne modele](/pl/ecosystem/models/) — Ceny tokenów stojące za ścieżkami przez CLI i Actions.
