# Pluginy deweloperskie Anthropic: code-review, feature-dev, pr-review-toolkit, security-guidance i inne

URL: https://developertoolkit.ai/pl/ecosystem/plugins/anthropic-dev-plugins/
Description: 14 pluginów Anthropic dla programistów Claude Code: co robi każdy, ile kosztuje w kontekście, nazwy wbudowane a pluginowe i przepływ od funkcji do PR.

Pluginy deweloperskie Anthropic to oficjalne pluginy Claude Code od samego Anthropic z marketplace'u `claude-plugins-official`; 14 opisanych tu pluginów dodaje przepływ budowy funkcji (`feature-dev`), przegląd pull requestów (`code-review`, `pr-review-toolkit`), kontrole bezpieczeństwa (`security-guidance`, `claude-security`), komendy gita, serwery językowe oraz narzędzia do tworzenia pluginów i skilli. Każda komenda pluginu ma przestrzeń nazw, więc `/code-review` to wbudowany recenzent, a `/code-review:code-review` to plugin.

Instalujesz `code-review`, wpisujesz `/code-review` i dostajesz lokalny przegląd zamiast komentarza w pull requeście, który obiecywał README. Kolega z zespołu dodaje `pr-review-toolkit` i od tej pory każda sesja niesie około 2000 dodatkowych tokenów. Nikt nie potrafi powiedzieć, które z trzech narzędzi bezpieczeństwa sprawdziło commit z zeszłego tygodnia. Ta strona jest dla programistów, którzy chcą, żeby te pluginy wykonały prawdziwą pracę przy jednej funkcji, i dla tech leadów, którzy decydują, które z nich zespół przypina. Jeśli nigdy nie instalowałeś pluginu, zacznij od [przeglądu pluginów i marketplace'ów](/pl/ecosystem/plugins/); ta strona zakłada, że wiesz, czym są `claude plugin install` i marketplace.

## Co wyniesiesz z tego przewodnika po pluginach

- Jedną tabelę z zadaniem każdego pluginu, liczbą instalacji i kosztem kontekstu zmierzonym na Claude Code 2.1.283
- Nazwy wbudowane i pluginowe, na których wszyscy się potykają, sprawdzone na liście komend wersji 2.1.283
- Przykładowe uruchomienie `/feature-dev:feature-dev` na małej funkcji, faza po fazie
- Przepływ od funkcji do scalonego PR, który łączy `feature-dev`, `pr-review-toolkit`, `commit-commands`, `code-review` i hooki `security-guidance`, z testami jako bramką
- Prompty do skopiowania, regułę `hookify`, która blokuje „gotowe” bez uruchomienia testów, oraz typowe awarie z krokami naprawy

## Jakie pluginy Anthropic istnieją i ile każdy kosztuje?

Liczby instalacji pochodzą ze strony każdego pluginu w katalogu claude.com/plugins, odczytanej 2026-09-26. Stałe tokeny to wynik `claude plugin details NAZWA` na Claude Code 2.1.283 z tego samego dnia: opisy ładowane do każdej sesji. Koszt przy wywołaniu płacisz dodatkowo za każdym razem, gdy uruchamia się skill lub agent.

| Plugin | Co dodaje | Instalacje | Stałe tokeny |
| ------ | --------- | ---------- | ------------ |
| `code-review` | `/code-review:code-review`: pięciu równoległych recenzentów na PR w GitHubie, odrzuca znaleziska poniżej 80/100 pewności, publikuje jeden komentarz | 438 525 | ~20 |
| `code-simplifier` | Jeden agent `code-simplifier` (alias modelu `opus`), który upraszcza ostatnio zmieniony kod bez zmiany zachowania | 346 763 | ~64 |
| `claude-md-management` | `/claude-md-management:revise-claude-md` i skill audytowy `claude-md-improver` | 287 247 | ~175 |
| `feature-dev` | `/feature-dev:feature-dev`, komenda w siedmiu fazach z agentami `code-explorer`, `code-architect` i `code-reviewer` | 256 017 | ~238 |
| `security-guidance` | Hooki na pięć zdarzeń: ostrzeżenia wzorcowe przy edycji, przegląd diffu przez LLM na zakończenie tury, agentowy przegląd przy `git commit` i `git push` (oraz komendach `gt` z Graphite) | 241 800 | ~0 (hooki działają poza kontekstem) |
| `typescript-lsp` | Rejestruje `typescript-language-server --stdio` dla `.ts`, `.tsx`, `.js`, `.jsx`, `.mts`, `.cts`, `.mjs`, `.cjs` | 212 522 | ~0 |
| `claude-code-setup` | Skill `claude-automation-recommender`, tylko do odczytu | 195 067 | ~139 |
| `commit-commands` | `/commit-commands:commit`, `commit-push-pr` i `clean_gone` | 171 244 | ~103 |
| `pr-review-toolkit` | `/pr-review-toolkit:review-pr` i sześciu agentów przeglądu | 114 856 | ~2033 |
| `pyright-lsp` | Rejestruje `pyright-langserver --stdio` dla `.py` i `.pyi` | 109 778 | ~0 |
| `plugin-dev` | Siedem skilli do pisania pluginów, komenda `/plugin-dev:create-plugin` i trzech agentów, w tym `plugin-validator` | 67 663 | ~2349 |
| `hookify` | Reguły hooków zapisane jako pliki Markdown oraz agent `conversation-analyzer` | 60 376 | ~292 |
| `skill-creator` | Jeden skill, który pisze, ewaluuje i benchmarkuje skille | brak strony w katalogu | ~112 |
| `claude-security` | Głębokie skany podatności z dziewięcioma agentami, zweryfikowanymi znaleziskami i wynikiem w SARIF | 8580 | ~776 |

Z tej tabeli wynikają dwie rzeczy. Cały zestaw do przeglądu i gita (`code-review`, `feature-dev`, `security-guidance`, `commit-commands`, `claude-md-management`, jeden plugin LSP) kosztuje poniżej 600 stałych tokenów, więc może działać w zakresie użytkownika. `pr-review-toolkit` i `plugin-dev` kosztują każdy więcej niż wszystkie tamte razem, więc instaluj je z `--scope project` w repozytoriach, które z nich korzystają. [Katalog najlepszych pluginów](/pl/ecosystem/plugins/top-plugins/) zestawia je z pluginami dostawców, takimi jak Vercel i Figma.

## Komenda wbudowana czy plugin: co się uruchomi?

Claude Code 2.1.283 pokazuje komendy pluginów tylko w formie `/PLUGIN:KOMENDA`, a wbudowane komendy mają te same gołe nazwy. Dowodem dla każdego wiersza poniżej jest lista komend samej sesji, odczytana ze zdarzenia `init` polecenia `claude -p --output-format stream-json --verbose` przy zainstalowanych wszystkich 14 pluginach.

| Wpisujesz | Co się uruchamia | Czego pewnie chciałeś, instalując plugin |
| --------- | ---------------- | ---------------------------------------- |
| `/code-review` | **Wbudowany** lokalny recenzent (opcje `--fix` i `--comment`) | `/code-review:code-review`, wieloagentowy przegląd PR z pluginu |
| `/review` | Ten sam **wbudowany** recenzent: `/review` to alias `/code-review` | `/pr-review-toolkit:review-pr`, przegląd zestawu w podziale na aspekty |
| `/simplify` | **Wbudowany** skill upraszczania | „use the code-simplifier agent on the files I changed”, co trafia do `code-simplifier:code-simplifier` |
| `/security-review` | **Wbudowany** przegląd bezpieczeństwa | `security-guidance` działa sam jako hooki; `/claude-security:claude-security` uruchamia głęboki skan |
| `/claude-security` | Nic: skill pluginu to `/claude-security:claude-security` (README pluginu pokazuje krótką formę) | `/claude-security:claude-security scan my branch at high` |
| `/hookify`, `/commit`, `/review-pr` | Nic: to skróty z README | `/hookify:hookify`, `/commit-commands:commit`, `/pr-review-toolkit:review-pr` |

Nazwy dzielą też agenci. `feature-dev:code-reviewer` i `pr-review-toolkit:code-reviewer` to różne prompty, podobnie jak `code-simplifier:code-simplifier` i `pr-review-toolkit:code-simplifier`. Gdy prosisz o „agenta code-reviewer” przy obu włączonych pluginach, podaj nazwę pluginu.

## Zainstaluj zestaw podstawowy

**Claude Code**

Uruchom to w terminalu. Oficjalny marketplace rejestruje się sam przy pierwszym interaktywnym starcie, więc linia `marketplace add` ma znaczenie tylko w skryptach i CI.

```bash
claude plugin marketplace add anthropics/claude-plugins-official
claude plugin install feature-dev@claude-plugins-official
claude plugin install security-guidance@claude-plugins-official
claude plugin install commit-commands@claude-plugins-official
claude plugin install code-review@claude-plugins-official
claude plugin install claude-md-management@claude-plugins-official
claude plugin install pr-review-toolkit@claude-plugins-official --scope project
claude plugin details feature-dev
```

Do nawigacji po symbolach najpierw zainstaluj serwer językowy, bo pluginy LSP tylko rejestrują komendę i nie zawierają binarki:

```bash
npm install -g typescript-language-server typescript
claude plugin install typescript-lsp@claude-plugins-official
npm install -g pyright          # or: pipx install pyright
claude plugin install pyright-lsp@claude-plugins-official
```

W otwartej sesji uruchom `/reload-plugins` albo zacznij nową. `security-guidance` wymaga Claude Code 2.1.144 lub nowszego i Pythona 3.8 lub nowszego w `PATH`. `code-review` i `commit-push-pr` potrzebują zalogowanego CLI `gh`.

**Codex**

Żadnego z tych pluginów nie ma we wbudowanym marketplace Codeksa `openai-curated` (manifest odczytany 2026-09-26), a napisano je pod format komend i hooków Claude Code. Najbliższe wbudowane odpowiedniki w codex-cli 0.157.1:

```bash
codex review --base main          # review this branch against main; --uncommitted and --commit SHA also exist
```

W TUI ten sam recenzent działa jako `/review`, a `/skills` pokazuje dołączony skill `skill-creator`, który wykonuje zadanie `skill-creator`; skill `plugin-creator`, który wykonywał zadanie `plugin-dev`, usunięto z wbudowanych skilli Codeksa w 0.159.0 (2026-09-29). Żeby użyć samego `skill-creator` od Anthropic, zainstaluj go jako skill:

```bash
npx skills add anthropics/skills --skill skill-creator -a codex
```

Do zadania, które wykonuje `claude-security`, `openai-curated` oferuje własny plugin OpenAI, `codex-security`. Zainstaluj go przez `/plugins` w TUI; formy powłokowej `codex plugin add codex-security@openai-curated` nie zweryfikowaliśmy na 0.157.1, bo kuratorowany marketplace pojawia się tylko w zalogowanej sesji. Opisuje go [strona o bezpieczeństwie w Codeksie](/pl/codex/operate/codex-security/).

**Cursor**

Żadnego z tych pluginów nie ma w oficjalnym marketplace Cursora `cursor-plugins` (manifest `cursor/plugins`, 94 pozycje, odczytany 2026-09-26). Do przeglądu pull requestów Cursor ma własne narzędzie, Bugbot, a manifest wymienia napisany przez Cursora plugin `pr-review-canvas`; do pisania pluginów `cursor/plugins` opisuje `/add-plugin create-plugin` w czacie Agenta. `skill-creator` od Anthropic zainstalujesz jako skill:

```bash
npx skills add anthropics/skills --skill skill-creator -a cursor
```

Ustawień pluginów w samej aplikacji Cursor nie zweryfikowaliśmy 2026-09-26, bo cursor.com był niedostępny ze środowiska, w którym powstawał tekst.

## Uruchom `/feature-dev:feature-dev` na małej funkcji

`feature-dev` to komenda w siedmiu fazach: Discovery, Codebase Exploration, Clarifying Questions, Architecture Design, Implementation, Quality Review i Summary. Trzy razy zatrzymuje się i czeka na ciebie, i właśnie o te przystanki chodzi: nie projektuje, zanim odpowiesz na pytania, i nie pisze kodu, zanim wybierzesz architekturę.

Przykładowa funkcja: limit prób logowania w API na Expressie.

```text
/feature-dev:feature-dev Add rate limiting to POST /api/login: at most 5 failed attempts per IP and per email in 15 minutes, then 429 with a Retry-After header. Successful login resets the email counter. Acceptance: tests in tests/auth/rate-limit.test.ts cover the limit, the reset, and the Retry-After value, and npm test passes.
```

Co zobaczysz w kolejnych fazach:

1. **Discovery.** Claude tworzy listę zadań dla wszystkich siedmiu faz i powtarza własnymi słowami, co ma zbudować. Jeśli opis jest ubogi, najpierw pyta, jaki problem rozwiązujesz.
2. **Eksploracja.** Dwóch lub trzech agentów `code-explorer` działa równolegle, każdy śledzi inny aspekt (istniejące middleware, przepływ uwierzytelniania, konfigurację testów) i zwraca od pięciu do dziesięciu plików do przeczytania. Claude je czyta i streszcza znalezione wzorce.
3. **Pytania.** Numerowana lista tego, co prośba zostawiła otwarte. Przy tej funkcji spodziewaj się pytań o to, gdzie trzymać liczniki (pamięć, Redis, baza danych), czy limit działa za proxy (`X-Forwarded-For`) i co widzi zablokowany użytkownik. Claude czeka. Jeśli odpowiesz „rób, jak uważasz”, poda rekomendację i poprosi o jej potwierdzenie.
4. **Architektura.** Dwóch lub trzech agentów `code-architect` proponuje zmianę minimalną, wersję z czystą architekturą i pragmatyczny środek. Claude je porównuje, rekomenduje jedną i pyta, którą wybierasz.
5. **Implementacja.** Dopiero po twojej wyraźnej zgodzie. Trzyma się wybranego planu i konwencji znalezionych przez eksploratorów.
6. **Przegląd jakości.** Trzech agentów `code-reviewer` sprawdza prostotę, poprawność i konwencje projektu; każdy zgłasza tylko problemy ocenione na co najmniej 80 na 100. Claude pyta, czy naprawić teraz, później, czy iść dalej.
7. **Podsumowanie.** Co powstało, jakie decyzje zapadły, które pliki się zmieniły i co dalej.

Agenci eksplorator, architekt i recenzent działają na aliasie modelu `sonnet`; orkiestracja działa na modelu twojej sesji. Sama komenda nigdy nie uruchamia twoich testów: faza 6 to agenci czytający kod. Dlatego linia akceptacji w prompcie wskazuje plik testów i komendę. Bez niej „gotowe” znaczy „trzech agentów nic nie znalazło”, a nie „zachowanie działa”.

**Prompt do skopiowania: feature-dev z bramką testów**

```text
/feature-dev:feature-dev Add CSV export to the reports page: a "Download CSV" button exports the currently filtered rows, columns in the on-screen order, dates in ISO 8601, and the file is named report-YYYY-MM-DD.csv. Acceptance: write the tests first (one for the filter, one for column order, one for an empty result), show them failing, then implement until they pass. In the quality review phase, run the full test suite, the type checker and the linter, and treat any failure as a Critical finding before you ask me what to fix.
```

## Połącz pluginy od funkcji do scalonego pull requesta

Każdy plugin odpowiada za jeden krok i zostawia po sobie coś, co da się sprawdzić. Kolejność poniżej celowo różni się od kolejności instalacji: `pr-review-toolkit` szuka plików do przeglądu przez `git diff --name-only`, a to pokazuje tylko zmiany nieprzygotowane do commita (unstaged), więc przegląd idzie, zanim cokolwiek dodasz do indeksu albo zacommitujesz.

1. **Zabezpiecz sesję.** Przy zainstalowanym `security-guidance` trzy warstwy działają bez twojej prośby. Edycje pasujące do około 25 niebezpiecznych wzorców (`yaml.load`, `pickle.load` na niezaufanych danych, surowe `innerHTML`, zaszyte sekrety) dostają natychmiastowe ostrzeżenie. Gdy kończy się tura, przegląd diffu w tle budzi sesję z poważnymi znaleziskami. Przy `git commit` i `git push` (oraz komendach `gt` z Graphite) agentowy recenzent czyta powiązane pliki, żeby prześledzić przepływ danych przez kod.
2. **Zbuduj.** Uruchom `/feature-dev:feature-dev` z kryteriami akceptacji, jak wyżej. Z pluginem LSP Claude rozwiązuje definicje i referencje przez serwer językowy zamiast wyszukiwania tekstu.
3. **Zweryfikuj.** Uruchom testy, sprawdzanie typów i linter samodzielnie albo w CI. To one są bramką; pluginy są recenzentami, a recenzenci się mylą.
4. **Przejrzyj lokalnie.** Uruchom `/pr-review-toolkit:review-pr tests errors types`, zanim dodasz zmiany do indeksu (`git add`) albo je zacommitujesz. Dobiera agentów do tego, co się zmieniło: `pr-test-analyzer`, gdy zmieniły się testy, `silent-failure-hunter`, gdy zmieniła się obsługa błędów, `type-design-analyzer`, gdy doszły typy. Znaleziska wracają jako Critical, Important i Suggestions.
5. **Wyślij.** Uruchom `/commit-commands:commit-push-pr`. Tworzy gałąź, jeśli jesteś na `main`, robi jeden commit, wypycha go i uruchamia `gh pr create`. Przeglądy commita i pusha z `security-guidance` działają w tle i raportują do sesji.
6. **Drugi przegląd na PR.** Uruchom `/code-review:code-review` na gałęzi PR. Sprawdza, czy PR się kwalifikuje, uruchamia pięciu równoległych recenzentów (zgodność z `CLAUDE.md`, oczywiste błędy, git blame i historia, komentarze z wcześniejszych PR dotykających tych plików, komentarze w kodzie), ocenia każde znalezisko od 0 do 100 i publikuje jeden komentarz z tymi od 80 w górę, z linkami do pełnego SHA commita. Jeśli nic nie przekracza 80, nie publikuje nic.
7. **Wyciągnij wnioski.** Uruchom `/claude-md-management:revise-claude-md`. Plugin analizuje, co ta sesja musiała odkryć, szkicuje jednolinijkowe uzupełnienia i pokazuje je, zanim zmieni `CLAUDE.md`.

**Prompt do skopiowania: zamień znaleziska przeglądu w dowód**

```text
Run /pr-review-toolkit:review-pr tests errors types on my unstaged changes. For each Critical and Important finding: state the input that triggers it, add a failing test that shows it, then fix the code and rerun that test. Finish with the full test suite and the type checker. Report a table with columns finding, agent, test name, fail-before, pass-after. Findings you cannot reproduce with a test go in a separate "not reproduced" list with your reasoning; do not change code for them.
```

### Kto zatwierdza i na podstawie jakich dowodów?

Pluginy zmniejszają to, co musi przeczytać człowiek, ale nie zastępują decyzji. Autor PR odpowiada za kryteria akceptacji i testy. Recenzent zatwierdza na podstawie dowodów: zielonego CI, tabeli znalezisko–test z promptu powyżej, komentarza `code-review` (albo jego braku) i znalezisk `security-guidance` odnotowanych w opisie PR. Człowiek czyta kod tylko w przypadkach eskalacji, które definiuje twój zespół, na przykład przy uwierzytelnianiu, płatnościach albo migracji. [Przepływ przeglądu PR tworzonych przez agenta](/pl/workflows/ship/agent-pr-review/) i [pakiet dowodów](/pl/workflows/ship/evidence-bundle/) definiują ten zestaw.

`code-review` celowo pomija problemy, które wyłapałby linter, sprawdzanie typów albo testy, a także ogólne uwagi o pokryciu testami czy bezpieczeństwie, chyba że prosi o nie `CLAUDE.md`: jego instrukcje zakładają, że CI uruchamia je osobno. Repozytorium bez bramek w CI dostaje więc od niego mniej, a nie więcej.

## Skonfiguruj security-guidance pod swój kod

`security-guidance` (w oficjalnym marketplace 2026-09-26 w wersji 2.0.8) konfigurujesz zmiennymi środowiskowymi i jednym opcjonalnym plikiem reguł; domyślne działanie nie wymaga żadnego z nich.

| Ustawienie | Efekt |
| ---------- | ----- |
| `.claude/claude-security-guidance.md` | Reguły projektu dodawane do przeglądu diffu na zakończenie tury, przeznaczone do commitowania. `~/.claude/claude-security-guidance.md` trzyma reguły użytkownika, a `.claude/claude-security-guidance.local.md` lokalne nadpisania. Trzy pliki są łączone w budżecie 8 KB, a recenzent commitów ich nie czyta |
| `SECURITY_REVIEW_MODEL` | Model przeglądu diffu. README pluginu podaje jako domyślny `claude-opus-4-7`, model w statusie Legacy; ustaw `claude-opus-5-5` (domyślny model Claude Code od v2.1.280 na obu kanałach wydań). Na Bedrock, Google Cloud albo Foundry użyj identyfikatora modelu w formie danego dostawcy. `SG_AGENTIC_MODEL` robi to samo dla recenzenta commitów |
| `ENABLE_STOP_REVIEW=0` | Zostawia przeglądy commita i pusha, wyłącza przegląd po każdej turze. Przydaje się, gdy kilku agentów dzieli jeden worktree, bo inny agent może przesunąć `HEAD` między turami |
| `ENABLE_PATTERN_RULES=0` · `ENABLE_COMMIT_REVIEW=0` | Wyłączają tylko ostrzeżenia regex albo tylko agentowy przegląd commitów |
| `SG_DUAL_OR=on` | Uruchamia równolegle dwa wywołania przeglądu i zachowuje sumę znalezisk. README podaje kilka punktów procentowych wyższej czułości przy mniej więcej dwukrotnym koszcie API za przegląd; zostaw to dla repozytoriów obsługujących płatności albo dane uwierzytelniające |
| `SECURITY_GUIDANCE_DISABLE=1` | Wyłącznik całego pluginu |

Pisz reguły, których model nie wywnioskuje z kodu: „wywołania `requests.get(url)` z `url` kontrolowanym przez użytkownika idą przez `acme.net.safe_request`”. Każdy przegląd wysyła zmienione ścieżki, fragmenty diffu i treść odpowiednich plików do skonfigurowanego endpointu modelu (API Anthropic, twojej bramki albo dostawcy chmury), a plik reguł idzie z każdym przeglądem, więc nie trzymaj w nim sekretów. Aktualne nazwy i ceny modeli znajdziesz w [przeglądzie modeli](/pl/ecosystem/models/).

## Wymuś „testy uruchomione” regułą hookify

`hookify` zamienia zdanie w regułę hooka zapisaną jako `.claude/hookify.NAZWA.local.md`, a reguła działa od następnego wywołania narzędzia, bez restartu. Zdarzenia reguł to `bash`, `file`, `stop`, `prompt` i `all`; akcje to `warn` i `block`. Ta reguła, zaadaptowana z przykładu `require-tests-stop` dołączonego do pluginu (który jest dostarczany z `enabled: false`), nie pozwala Claude zakończyć tury, dopóki w transkrypcie sesji nie pojawi się żadne z `npm test`, `pytest` ani `go test`:

```markdown
---
name: require-tests-run
enabled: true
event: stop
action: block
conditions:
  - field: transcript
    operator: not_contains
    pattern: npm test
  - field: transcript
    operator: not_contains
    pattern: pytest
  - field: transcript
    operator: not_contains
    pattern: go test
---

No test run found in this session. Run the test suite and report the result before you stop.
```

O tym, czy reguła działa, decydują dwa szczegóły, oba odczytane z `hookify/core/rule_engine.py` w oficjalnym marketplace 2026-09-26:

- **`not_contains` to dosłowne sprawdzenie podciągu, a nie wyrażenie regularne.** Jeden warunek z `pattern: npm test|pytest|go test` szuka dokładnie tego napisu, nigdy go nie znajduje i blokuje każde zakończenie tury, nawet po uruchomieniu testów (przykład w pluginie używa tej samej alternatywy `|`: `npm test|pytest|cargo test`). Warunki łączy się przez AND, więc osobny `not_contains` dla każdej komendy blokuje tylko wtedy, gdy brakuje wszystkich trzech. Gdy potrzebujesz alternatywy, użyj `regex_match`.
- **Transkrypt zawiera też twoje prompty i wiadomości Claude.** Prompt z limitem logowania wyżej na tej stronie zawiera „npm test passes”, co spełnia regułę bez żadnego uruchomienia testów. Nie wpisuj komend testów do promptów albo dopasuj napis, który drukuje tylko twój runner, na przykład `passed in` z pytesta. Zapisanie pliku reguły w sesji też umieszcza `npm test` w jej transkrypcie, więc sprawdzaj regułę w nowej sesji.

Zapisz ją jako `.claude/hookify.require-tests-run.local.md` albo poproś o nią słowami:

**Prompt do skopiowania: reguła weryfikacji przez hookify**

```text
/hookify:hookify Block stopping when the transcript has no run of npm test (one literal not_contains condition per test command, no | alternation), and warn whenever a Bash command runs git push --force. Show me both rule files before you save them.
```

Reguły wylistujesz przez `/hookify:list`, a włączysz lub wyłączysz przez `/hookify:configure`. `/hookify:hookify` bez argumentów każe agentowi `conversation-analyzer` przeszukać sesję pod kątem zachowań, które poprawiałeś, i zaproponować dla nich reguły. [Przewodnik po automatyzacji hookami](/pl/claude-code/automate/hooks-automation/) opisuje ręcznie pisane hooki na wypadek, gdy reguła z wyrażeniem regularnym nie wystarcza.

## Użyj reszty zestawu tam, gdzie pasuje

- **`claude-security`** uruchamia skanowanie Claude Security od Anthropic wewnątrz twojej sesji. `/claude-security:claude-security` oferuje trzy zadania: skan całego kodu, skan zmian (gałęzi, diffu PR albo jednego commita) i propozycje łatek. Każde kandydujące znalezisko trafia do agentów weryfikujących, których zadaniem jest je obalić, a wyniki lądują w `CLAUDE-SECURITY-ZNACZNIK_CZASU/` jako Markdown, JSONL i SARIF 2.1.0 dla GitHub code scanning. README zaleca Claude Opus 5.5 albo Claude Fable 5.1. Plugin działa z twoimi uprawnieniami i nie dodaje własnej izolacji, więc niezaufane repozytoria skanuj tylko w sandboksie. [Strona o bramkach bezpieczeństwa](/pl/ecosystem/observability/agent-security-gates/) umieszcza go obok innych skanerów.
- **`code-simplifier`** to jeden agent na moment, gdy funkcja jest już zielona: „use the code-simplifier agent on the files I changed in this branch”. Potem uruchom testy ponownie; „nie zmienia działania” to polecenie dla modelu, a nie gwarancja.
- **`claude-code-setup`** przydaje się w pierwszym tygodniu pracy z repozytorium: poproś „recommend automations for this project”, a dostaniesz jeden lub dwa hooki, skille, serwery MCP i subagentów w każdej kategorii, każdy z uzasadnieniem. Skill działa tylko do odczytu i nie zmienia plików.
- **`plugin-dev`** służy do pisania własnego pluginu: `/plugin-dev:create-plugin` tworzy szkielet, a agent `plugin-validator` go sprawdza. Przy ~2349 stałych tokenach włączaj go na czas pisania i wyłączaj potem. Następnie dodaj `claude plugin validate --strict` do CI, jak pokazuje [budowa pluginów](/pl/ecosystem/plugins/building-plugins/).
- **`skill-creator`** pisze skill, uruchamia ewaluacje z nim i bez niego oraz mierzy rozrzut wyników. Użyj go, zanim udostępnisz skill, żeby zespół przyjął go na podstawie zmierzonej różnicy. Zobacz [budowę własnych skilli](/pl/ecosystem/skills/building-custom-skills/).

**Prompt do skopiowania: skan gałęzi przed PR**

```text
/claude-security:claude-security scan the changes on this branch against main at high effort. When the report is written, list each finding with severity, file and line, and the exploit precondition. For HIGH and CRITICAL findings, suggest patches but do not apply them; I will review the patch files first.
```

**Pułapki sprawdzone na Claude Code 2.1.283, 2026-09-26**

- `/code-review` (i jego alias `/review`), `/simplify` i `/security-review` to komendy wbudowane. Pluginy to `/code-review:code-review`, agent `code-simplifier` i hooki `security-guidance`.
- Skróty z README, takie jak `/hookify`, `/commit`, `/review-pr` i `/claude-security`, nie występują na liście komend; używaj formy `/PLUGIN:KOMENDA`.
- `claude plugin add` to nieznana komenda; właściwy czasownik to `install`.
- `typescript-lsp` i `pyright-lsp` uruchamiają `typescript-language-server` i `pyright-langserver` z twojego `PATH` i nic nie robią, gdy binarki brakuje.
- `ralph-wiggum@claude-plugins-official` nie istnieje; oficjalny plugin pętli to `ralph-loop`.

## Co psuje się w pluginach Anthropic i jak z tego wyjść

- **Pierwsza sesja po instalacji `security-guidance` wisi przy starcie.** Hook `SessionStart` przygotowuje środowisko Pythona z Claude Agent SDK w `~/.claude/security/`, z limitem 180 sekund. Pozwól mu raz skończyć. Jeśli przeglądy nigdy nic nie zgłaszają, sprawdź `~/.claude/security/log.txt`, a na Bedrock, Google Cloud albo Foundry ustaw `SECURITY_REVIEW_MODEL` w formie identyfikatora modelu danego dostawcy.
- **`feature-dev` pyta o rzeczy, które uważasz za ustalone.** Ma polecenie, by nigdy nie pomijać fazy 3. Wpisz decyzje do pierwszego promptu („use Redis, trust `X-Forwarded-For` from our load balancer”), a pytania skurczą się do tego, co naprawdę otwarte.
- **`/pr-review-toolkit:review-pr` mówi, że nie ma czego przeglądać.** Listuje pliki przez `git diff --name-only`, które pokazuje tylko zmiany spoza indeksu, więc nie widzi ani zmian dodanych przez `git add`, ani zacommitowanych. Uruchom go, zanim cokolwiek dodasz do indeksu, albo poproś „review the changes on this branch against main with /pr-review-toolkit:review-pr”.
- **`code-review` nic nie opublikował.** To zamierzony wynik, gdy żadne znalezisko nie ma 80 punktów lub więcej albo gdy PR jest zamknięty, jest szkicem, jest trywialny lub już przejrzany. Jeśli spodziewałeś się komentarza, sprawdź `gh auth status`.
- **`commit-push-pr` zacommitował plik, którego nie chciałeś.** Jego narzędzia pozwalają na `git add` czegokolwiek w drzewie roboczym. Najpierw uruchom `git status` i trzymaj wygenerowane pliki w `.gitignore`. Żeby to naprawić, zanim ktoś pobierze zmiany, uruchom `git reset --soft HEAD~1`, potem `git restore --staged <plik>` i dopisz plik do `.gitignore`, potem `git commit -m "<opis>"`, a na końcu `git push --force-with-lease`. Push zaraz po resecie usunąłby z gałęzi PR cały commit, a nie tylko ten plik.
- **`security-guidance` wciąż zgłasza kod, o którym wiesz, że jest bezpieczny.** Dodaj w tej linii komentarz wyjaśniający, dlaczego jest bezpieczna; recenzent diffu traktuje takie uzasadnienia jako wyłączenia. Całą klasę fałszywych alarmów opisz jako wyjątek w `.claude/claude-security-guidance.md`, żeby dostał go każdy programista.
- **Równolegli agenci zgłaszają to samo znalezisko bezpieczeństwa.** Ustaw `ENABLE_STOP_REVIEW=0` w środowisku każdego agenta i polegaj na przeglądzie commitów albo daj każdemu agentowi własny worktree.

## Co dalej z pluginami Anthropic

- [Przegląd pluginów i marketplace'ów](/pl/ecosystem/plugins/) — Co zawiera plugin, komendy w każdym agencie i jak zespół zawęża listę dozwolonych marketplace'ów.
- [Pluginy warte instalacji](/pl/ecosystem/plugins/top-plugins/) — 20 najczęściej instalowanych pluginów, w tym pakiety dostawców, ze zmierzonym kosztem kontekstu.
- [Boty do code review: porównanie](/pl/ecosystem/observability/ai-code-review-bots/) — Gdzie plugin code-review stoi obok zarządzanego Code Review, Bugbota i botów zewnętrznych.
- [Zbuduj plugin albo prywatny marketplace](/pl/ecosystem/plugins/building-plugins/) — Spakuj własne komendy przeglądu i hooki, a potem przypnij je dla zespołu.
