# 25 najczęściej instalowanych skilli praktyk programistycznych (wrzesień 2026)

URL: https://developertoolkit.ai/pl/ecosystem/skills/top-practice-skills/
Description: 25 najczęściej instalowanych skilli praktyk dla Claude Code, Codeksa i Cursora, startowe trio dla nowego repo i łączenie ich w zweryfikowaną pętlę.

Najczęściej instalowane skille praktyk programistycznych we wrześniu 2026 to `find-skills`, skille Matta Pococka do uzgadniania planu i pracy inżynierskiej (`grill-me`, `grill-with-docs`, `tdd`, `to-spec`, `code-review`), `frontend-design` od Anthropic oraz skille metodyki Superpowers. Liczba instalacji mierzy zainteresowanie, nie jakość. Najwięcej daje połączenie trzech skilli w jedną zweryfikowaną pętlę, a nie instalacja wszystkich 25.

Wyszukujesz na skills.sh „superpowers”, instalujesz pierwszy wynik i dostajesz skille do generowania wideo AI. Kolega skopiował z bloga `npx skills add mattpocock/skills --skill=grill-me` i zainstalował wszystkie skille z repozytorium. Ktoś inny zainstalował samo `grill-me` i nic się nie dzieje, bo ten skill to jednolinijkowy odsyłacz do innego skilla. Ta strona jest dla developerów, którzy chcą tych kilku skilli, które naprawdę zmieniają sposób pracy agenta, i dla tech leadów, którzy muszą uczynić ten zestaw powtarzalnym dla całego zespołu.

## Co daje ci ten ranking skilli praktyk

- 25 najczęściej instalowanych skilli praktyk według jawnych reguł doboru: co każdy każe robić agentowi i datowana liczba instalacji
- Skille, które Claude Code i Codex mają już wbudowane, żebyś nie instalował duplikatu
- Startowe trio dla nowego repozytorium (`find-skills`, `grill-me`, `tdd`) z poleceniami instalacji dla Claude Code, Codeksa i Cursora
- Pięcioetapową pętlę złożoną z pojedynczych skilli, bez frameworka: przepytanie, specyfikacja, najpierw test, weryfikacja, review
- Pułapki rankingu: repozytoria-podróbki, skille po zmianie nazwy, które wciąż są wysoko, i skille, które psują się zainstalowane w pojedynkę

## Które skille praktyk programistycznych są najczęściej instalowane we wrześniu 2026?

**Popularność na dzień 2026-09-26:** łączna liczba instalacji na [skills.sh](https://skills.sh), wzięta z zewnętrznego zrzutu `LinklyAI/best-skills` z datą 2026-09-26. Liczby ze skills.sh to zrzut zewnętrznego serwisu; zanim zacytujesz liczbę, sprawdź ponownie stronę skilla na skills.sh. Instalacja na skills.sh to jedna instalacja jednego skilla przez CLI dla każdego agenta i projektu. Instalacje pluginów i gwiazdki na GitHubie to osobne miary, więc porównuj liczby tylko w obrębie jednej kolumny.

Skill praktyk to tutaj taki, który zmienia sposób, w jaki sam agent pracuje nad kodem, niezależnie od stosu: jak planuje, buduje, testuje, debuguje i robi review albo jak gospodaruje sesją. Tabela to 25 najczęściej instalowanych skilli, które zostają po zastosowaniu poniższych reguł, a każdy skill z wynikiem wyższym niż wiersz 25 (221 579), którego w niej brak, podpada pod jedną z nich:

- **Poza zakresem tej strony.** Automatyzacja przeglądarki, np. `agent-browser` (944 783), omówiona w [automatyzacji przeglądarki](/pl/ecosystem/mcp/browser-automation/). Skille związane z konkretnym frameworkiem, np. `vercel-react-best-practices` (744 240) i `migrate-to-shoehorn` Pococka (380 312); frontendowe omawiają [najlepsze skille do frontendu](/pl/ecosystem/skills/top-skills-frontend/). Skille dostawców, produktów, formatów dokumentów i generowania mediów (Lark, Azure, Prisma, Supabase, zestaw RigorPilot do badań nad deep learningiem, generatory wideo i obrazów, `pptx` 226 882).
- **Wliczone do wiersza.** Skille pomocnicze, które wywołują tylko inne skille (`setup-matt-pocock-skills` 892 911, `domain-modeling` 700 766, `codebase-design` 678 419), liczymy razem ze skillem, który ich potrzebuje, a `using-superpowers` z Superpowers (253 058), który tylko każe agentowi wczytać pozostałe skille Superpowers, razem z nimi. W repozytoriach jednego zastosowania wiersz zajmuje najczęściej instalowany skill, a reszta to jego warianty: pozostałe skille `caveman-*`, np. `caveman-commit` (378 782), i presety stylu z taste-skill, np. `high-end-visual-design` (380 958).
- **Wycofane nazwy.** Rankingi wciąż pokazują nazwy, których folderu nie ma już na `main`: `to-prd`, `to-issues`, `diagnose`, `write-a-skill` (230 669), `zoom-out` (230 145), `writing-great-skills` (324 259) i własny `caveman` Pococka (224 563). Nie liczymy ich.
- **Skille w becie.** Folder `in-progress/` Pococka to beta: autor trzyma go poza pluginem i zastrzega, że te skille mogą się zmienić albo zniknąć. Dotyczy to `loop-me` (339 337), `claude-handoff` (315 856, wariant wiersza 7 `handoff` z agentem w tle), `setup-ts-deep-modules` (270 938) oraz trójki `writing-beats`, `writing-shape` i `writing-fragments` (384 495, 384 019 i 383 815).
- **Skille dla twojego zrozumienia.** `teach` (712 278) uczy cię jakiegoś pojęcia, `ask-matt` (614 785) podpowiada, który skill Pococka pasuje, a `wait-what` (304 458) jeszcze raz tłumaczy ostatnią wiadomość. Żaden z nich nie zmienia pracy samego agenta.
- **Uruchamiane raz na repozytorium.** `git-guardrails-claude-code` (399 307) i `setup-pre-commit` (390 884) instalują hooki i na tym kończą swoją rolę.
- **Kroki, które może wykonać tylko człowiek.** `wizard` (413 623) to skill do konkretnego zadania: pisze interaktywny skrypt bash, który prowadzi człowieka przez przygotowanie infrastruktury, dane uwierzytelniające, sekrety CI, panel zewnętrznej usługi albo jednorazową migrację.
- **Wynik dla ludzi spoza pętli pracy nad kodem.** `scaffold-exercises` (384 053) tworzy ćwiczenia do kursu, a `to-questionnaire` (362 929) pisze kwestionariusz do wypełnienia przez współpracownika. Dokumenty przekazania i specyfikacje zostają w tabeli, bo na nich pracuje kolejny agent albo `implement`.
- **Drugi skill do pisania skilli.** `writing-for-agents` (318 126) to przewodnik po tym, jak formułować skille i pliki `AGENTS.md`. Pisanie skilli ma już swój wiersz w `skill-creator`, który dodatkowo sprawdza, czy skill się uruchamia.
- **Limity.** Trzy wąskie skille inżynierskie Pococka (`wayfinder` 567 931, `research` 563 441, `resolving-merge-conflicts` 541 100) są na liście pod tabelą, żeby jedno repozytorium nie zajęło jej połowy. Tabela kończy się też na pięciu skillach do projektowania UI, więc tam trafił również `emil-design-eng` (298 480).

| #  | Skill (repozytorium)                                           | Co każe robić agentowi                                                            | Instalacje łącznie        |
| -- | -------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------- |
| 1  | `find-skills` (vercel-labs/skills)                             | Przeszukuje indeks skills.sh i podaje polecenie instalacji                        | 3 568 681                 |
| 2  | `grill-me` + `grilling` (mattpocock/skills)                    | Przepytuje cię pytanie po pytaniu, aż plan przestanie być niejednoznaczny        | 1 225 243 (`grilling` 776 905) |
| 3  | `grill-with-docs` (mattpocock/skills)                          | Przepytuje i zapisuje uzgodnione pojęcia w `CONTEXT.md`, a decyzje w ADR-ach      | 1 046 834                 |
| 4  | `improve-codebase-architecture` (mattpocock/skills)            | Przegląda ostatnio zmieniany kod pod kątem refaktoryzacji, potem cię przepytuje   | 994 519                   |
| 5  | `tdd` (mattpocock/skills)                                      | Pętla red-green, jeden pionowy wycinek naraz, na uzgodnionych szwach testowych  | 966 524                   |
| 6  | `frontend-design` (anthropics/skills)                          | Wybiera kierunek wizualny, zanim napisze kod UI                                   | 923 303                   |
| 7  | `handoff` (mattpocock/skills)                                  | Kompresuje sesję do dokumentu przekazania dla nowej sesji                         | 869 575                   |
| 8  | `triage` (mattpocock/skills)                                   | Przeprowadza issues i pull requesty przez stany triage i pisze briefy dla agenta  | 842 438                   |
| 9  | `prototype` (mattpocock/skills)                                | Buduje prototyp do wyrzucenia, który odpowiada na jedno pytanie projektowe        | 840 310                   |
| 10 | `web-design-guidelines` (vercel-labs/agent-skills)             | Sprawdza kod UI według reguł interfejsu i dostępności Vercela                     | 667 369                   |
| 11 | `diagnosing-bugs` (mattpocock/skills, dawniej `diagnose`)      | Buduje szybką pętlę pass/fail, zanim zaproponuje poprawkę                         | 665 090                   |
| 12 | `code-review` (mattpocock/skills)                              | Review diffu w dwóch osiach, standardy repo i specyfikacja, w równoległych subagentach | 617 608              |
| 13 | `implement` (mattpocock/skills)                                | Implementuje specyfikację lub tickety przez `tdd`, potem uruchamia `code-review`  | 615 466                   |
| 14 | `to-spec` + `to-tickets` (mattpocock/skills, dawniej `to-prd`, `to-issues`) | Zamienia rozmowę z przepytania w specyfikację w trackerze, potem w tickety | 564 128 / 553 947    |
| 15 | `caveman` (JuliusBrussee/caveman)                              | Odpowiada skompresowanymi fragmentami, żeby oszczędzać tokeny wyjściowe           | 539 286                   |
| 16 | `design-taste-frontend` (Leonxlnx/taste-skill)                 | Narzuca UI ograniczenia układu, typografii i odstępów przeciw generycznym wzorcom  | 520 147                   |
| 17 | `skill-creator` (anthropics/skills)                            | Pisze szkic skilla i sprawdza, czy się uruchamia                                  | 391 071                   |
| 18 | `brainstorming` (obra/superpowers)                             | Bramka „najpierw projekt”: pytania, warianty, zatwierdzony dokument przed kodem   | 376 352                   |
| 19 | `ui-ux-pro-max` (nextlevelbuilder/ui-ux-pro-max-skill)         | Generuje design system z dołączonych danych o stylach przed kodem UI              | 371 037                   |
| 20 | `impeccable` (pbakaus/impeccable)                              | Wspólne słownictwo projektowe plus deterministyczny detektor problemów w UI       | 293 766                   |
| 21 | `systematic-debugging` (obra/superpowers)                      | Najpierw przyczyna źródłowa, potem poprawka, w czterech fazach                    | 271 653                   |
| 22 | `writing-plans` / `executing-plans` / `subagent-driven-development` (obra/superpowers) | Małe zaplanowane zadania, potem świeży subagent na każde, z review pomiędzy | 259 438 / 221 666 / 214 541 |
| 23 | `requesting-code-review` / `receiving-code-review` (obra/superpowers) | Prosi o review między zadaniami; weryfikuje uwagi, zanim je wdroży       | 238 401 / 202 093         |
| 24 | `test-driven-development` (obra/superpowers)                   | Ścisłe red-green-refactor, test przed jakimkolwiek kodem implementacji            | 236 900                   |
| 25 | `verification-before-completion` (obra/superpowers)            | Uruchamia polecenie dowodowe i czyta wynik przed każdym „gotowe”                  | 221 579                   |

Listę zdominowały dwa repozytoria. `mattpocock/skills` Matta Pococka (269,8 tys. gwiazdek na GitHubie 2026-09-26) ma 11 z 25 wierszy, a `obra/superpowers` (291,7 tys. gwiazdek) sześć, z czego jeden grupuje trzy skille. Każdą grupę szczegółowo omawiają strony [Grill Me i Grill With Docs](/pl/ecosystem/skills/grill-me/), [workflow Superpowers](/pl/ecosystem/frameworks/superpowers/) oraz zestaw frontendowy w [najlepszych skillach do frontendu](/pl/ecosystem/skills/top-skills-frontend/).

### Które skille praktyk są tuż pod kreską?

Są zweryfikowane i przydatne, ale mają mniej instalacji niż `verification-before-completion`, odsuwają je reguły opisane wyżej albo mierzy się je tylko gwiazdkami na GitHubie (odczyt 2026-09-26):

- `wayfinder`, `research` i `resolving-merge-conflicts` (mattpocock/skills, 567 931, 563 441 i 541 100 instalacji): planowanie pracy zbyt dużej na jedną sesję jako ticketów decyzyjnych w trackerze zadań, zbadanie pytania na podstawie źródeł pierwotnych z zapisem do pliku Markdown oraz rozwiązanie trwającego konfliktu merge lub rebase na podstawie pierwotnej intencji każdej ze stron.
- `git-guardrails-claude-code` i `setup-pre-commit` (mattpocock/skills, folder `misc/`, 399 307 i 390 884 instalacje): hook `PreToolUse` w Claude Code, który blokuje destrukcyjne polecenia gita, takie jak `push` i `reset --hard`, oraz hooki pre-commit Husky z lint-staged, sprawdzaniem typów i testami. Każdy uruchamiasz raz na repozytorium.
- `wizard` (mattpocock/skills, 413 623 instalacje): generuje interaktywny skrypt bash, który prowadzi człowieka przez kroki, jakie tylko on może wykonać, na przykład ustawienie sekretów CI albo jednorazową migrację. Sięgasz po niego przy konkretnym zadaniu, a nie raz na repozytorium.
- `emil-design-eng` (emilkowalski/skills, 298 480 instalacji): przewodnik Emila Kowalskiego po design engineeringu, czyli decyzjach o animacjach, krzywych easingu, sprężynach i dopracowaniu komponentów. Review kodu UI podaje w tabeli „przed/po”.
- `claude-handoff` (mattpocock/skills, beta, 315 856 instalacji): przekazuje rozmowę nowemu agentowi w tle przez `claude --bg`, z podsumowaniem przekazania jako promptem, zamiast zapisywać dokument przekazania.
- `using-git-worktrees` i `finishing-a-development-branch` (obra/superpowers, 199 093 i 195 607 instalacji): izolowany worktree z zielonym punktem wyjścia, a na końcu wybór: merge, pull request, zostawienie lub porzucenie gałęzi.
- `webapp-testing` (anthropics/skills, 164 051 instalacji): testy Playwright w Pythonie na lokalnej aplikacji webowej. Wymaga Pythona i Playwrighta na maszynie.
- `mcp-builder` (anthropics/skills, 118 601 instalacji): przewodnik po budowie serwerów MCP w Pythonie lub TypeScripcie.
- `doc-coauthoring` (anthropics/skills, 86 463 instalacje) i `writing-guidelines` (vercel-labs/agent-skills, 75 985 instalacji): współpisanie i review dokumentacji oraz specyfikacji.
- `karpathy-guidelines` (forrestchang/andrej-karpathy-skills, obecnie przekierowane do `multica-ai`, 215,2 tys. gwiazdek): ujawniaj założenia, rób chirurgiczne zmiany, definiuj weryfikowalne kryteria sukcesu.
- `humanizer` (blader/humanizer, 52 tys. gwiazdek): przepisuje prozę brzmiącą jak AI; zobacz [skille przeciw „slopowi” w tekstach](/pl/ecosystem/skills/unslop/).
- `planning-with-files` (OthmanAdi/planning-with-files, 27,1 tys. gwiazdek): trzyma plan w plikach na dysku, więc przetrwa kompaktowanie kontekstu.
- Skille Trail of Bits (trailofbits/skills, 7,3 tys. gwiazdek): marketplace 44 pluginów do review bezpieczeństwa, m.in. `differential-review`, `static-analysis` i `variant-analysis`.
- Agent Skills for Context Engineering (muratcankoylan, ok. 18 tys. gwiazdek): 17 skilli dla osób budujących systemy agentowe. CLI skills widzi tylko skill-opakowanie, dopóki nie dodasz `--full-depth`.

### Co Claude Code i Codex mają już wbudowane?

Zanim zainstalujesz skill od zewnętrznego autora, sprawdź, czy wbudowany skill nie robi tego samego.

**Claude Code**

Claude Code 2.1.283 ma wbudowane te skille praktyk ([dokumentacja poleceń](https://code.claude.com/docs/en/commands) oznacza je jako **Skill**):

- `/code-review [low|medium|high|xhigh|max|ultra] [--fix] [--comment] [pr#|branch|path]` szuka błędów poprawności w diffie lub pull requeście. `/review` to alias.
- `/simplify [target]` przegląda zmieniony kod pod kątem ponownego użycia, uproszczeń, wydajności i poziomu abstrakcji, a potem nanosi poprawki. Nie szuka błędów.
- `/verify` buduje i uruchamia aplikację, żeby potwierdzić, że zmiana działa. Działa tylko wtedy, gdy go wywołasz.
- `/run` uruchamia aplikację i nią steruje; `/run-skill-generator` zapisuje przepis uruchomienia jako `.claude/skills/run-<name>/`.
- `/batch <instruction>` dzieli dużą zmianę na 5 do 30 jednostek, każdą w osobnym worktree.

`/debug` nie jest metodą debugowania twojej aplikacji: włącza logowanie debug sesji. Do błędów w aplikacji użyj `diagnosing-bugs` albo `systematic-debugging`. Wbudowane skille wyłączysz ustawieniem `disableBundledSkills`.

**Codex**

Plik wykonywalny codex-cli 0.157.1 zawiera trzy skille systemowe: `$skill-installer`, `$skill-creator` i `$plugin-creator`; OpenAI usunęło `$plugin-creator` z wbudowanych skilli w 0.159.0 (2026-09-29), a wbudowane skille w 0.162.1 to `imagegen`, `openai-docs`, `review-agent`, `skill-creator` i `skill-installer`. `$skill-installer` instaluje z katalogu `openai/skills`, który jest teraz oznaczony jako przestarzały na rzecz `openai/plugins` (marketplace `openai-curated`). Codex ma też wbudowane polecenia `/review` i `codex review`. Wszystko inne z tabeli pochodzi z `npx skills add` albo z pluginu.

**Cursor**

Cursor ma wbudowany skill `/loop` (Cursor 3.5, 2026-05-20), który powtarza zadanie, a nie wymusza praktykę. Cursor ładuje skille z `.agents/skills/`, `.cursor/skills/` i ich odpowiedników w katalogu domowym (`~/.agents/skills/`, `~/.cursor/skills/`), a dla zgodności także z katalogów `.claude/skills/` i `.codex/skills/` (dokumentacja skilli Cursora, sprawdzone 2026-10-12). Każdy skill praktyk z tabeli traktuj jako coś, co instalujesz: przez CLI skills do `.agents/skills/` albo jako plugin przez `/add-plugin`, jeśli README danego skilla opisuje tę drogę.

## Jak czytać liczby instalacji skilli, żeby nie dać się zwieść?

Wysoka liczba to powód, żeby skill przeczytać, a nie żeby go instalować. Ranking zniekształcają cztery zjawiska:

1. **Podróbki „superpowers”.** Zrzut z 2026-09-26 pokazuje `101-skills/superpowers`, `qu-skills/superpowers`, `magentosh/superpowers` i `skills-shell/superpowers`; każda z tych podróbek ma od 120 tys. do 480 tys. instalacji. Ich skille to `ai-video-generation`, `twitter-automation` i podobne, bez związku z metodyką. Prawdziwe jest tylko `obra/superpowers`, a wyszukiwanie „superpowers” na skills.sh pokazuje najpierw kopie, bo mają więcej instalacji.
2. **Skille po zmianie nazwy zachowują liczniki.** `mattpocock/skills@to-prd` (368 270), `to-issues` (355 198) i `diagnose` (239 259) wciąż są w pierwszej trzysetce, choć ich katalogi zwracają 404 na `main`. Obecne nazwy to `to-spec`, `to-tickets` i `diagnosing-bugs`.
3. **Skille-delegaty.** `grill-me` Pococka zawiera jedną instrukcję: wywołaj skill `grilling`. `grill-with-docs` wywołuje `grilling` i `domain-modeling`, a `tdd` korzysta z `codebase-design`. Licznik `grill-me` nic nie mówi o tym, czy obok zainstalowałeś `grilling`.
4. **Forki opublikowane pod innymi właścicielami.** Instaluj tylko od kanonicznego właściciela (`mattpocock`, `obra`, `anthropics`, `vercel-labs`) i przeczytaj `SKILL.md` przed instalacją, tak jak opisuje to strona o [bezpieczeństwie łańcucha dostaw skilli](/pl/ecosystem/skills/skill-security/).

## Zainstaluj startowe trio w nowym repo: find-skills, grill-me i tdd

Trzy skille zamykają luki, które większość zespołów odczuwa najpierw. `find-skills` sprawia, że nie zgadujesz nazw. `grill-me` powstrzymuje agenta przed budowaniem nie tego, co trzeba. `tdd` sprawia, że każda zmiana przychodzi z testem, który najpierw nie przechodził. W istniejącej bazie kodu Pocock zaleca `grill-with-docs` (zainstaluj razem z nim `grilling` i `domain-modeling`); `grill-me` to lżejszy wariant, niezwiązany z kodem. Instaluj je na poziomie projektu, żeby trafiły do repozytorium i każdy w zespole miał ten sam zestaw.

1. **Zainstaluj trzy skille i ich zależności.** Uruchom to w katalogu głównym repozytorium. CLI skills to pakiet npm `skills` 1.7.0.

    **Claude Code**

    ```bash
    # Pocock's skills as a plugin from the official marketplace (updates itself)
    claude plugin install mattpocock-skills --scope project
    # find-skills is not in a plugin; install it as a project skill
    npx skills add vercel-labs/skills --skill find-skills -a claude-code -y
    ```

    `--scope project` zapisuje plugin w `.claude/settings.json`, który commitujesz; bez tej opcji plugin instaluje się tylko dla ciebie. Oficjalny marketplace dodaje się przy pierwszym uruchomieniu sesji interaktywnej; w skrypcie najpierw wykonaj `claude plugin marketplace add anthropics/claude-plugins-official`. Plugin dodaje przestrzeń nazw do skilli: wpisujesz `/mattpocock-skills:grill-me`. Dla skilli Pococka wybierz plugin **albo** przenośną kopię, nie oba, bo inaczej każdy skill pojawi się dwa razy.

    **Codex**

    ```bash
    npx skills add vercel-labs/skills --skill find-skills -a codex -y
    npx skills add mattpocock/skills --skill grill-me grilling tdd codebase-design -a codex -y
    ```

    Oba polecenia zapisują do `.agents/skills/`. Codex wywołuje skill znakiem `$`: `$grill-me`.

    **Cursor**

    ```bash
    npx skills add vercel-labs/skills --skill find-skills -a cursor -y
    npx skills add mattpocock/skills --skill grill-me grilling tdd codebase-design -a cursor -y
    ```

    Oba polecenia zapisują do `.agents/skills/`. Dokumentacja skilli Cursora (nie sprawdzana ponownie 2026-09-26) opisuje wywołanie skilla jako `/grill-me` w czacie Agenta; jeśli polecenie się nie pojawia, poproś agenta, żeby użył skilla grill-me, podając jego nazwę.

2. **Sprawdź, co się zainstalowało.** Uruchom `npx skills list` i upewnij się, że obok wskazanych skilli są `grilling` i `codebase-design`. W Claude Code uruchom `/context` przed instalacją i po niej, żeby zobaczyć koszt listy skilli, a `claude plugin details mattpocock-skills` pokaże zawartość pluginu i przewidywany koszt w tokenach. Każdy skill dokłada nazwę i opis do każdej sesji; treść ładuje się dopiero, gdy skill się uruchomi. Dla skali: 2026-09-26 `claude plugin details` w Claude Code 2.1.283 wyliczył dla całego pluginu `mattpocock-skills` (1.2.3, 25 skilli) około 1609 tokenów stałego kosztu, więc trzy przenośne skille to niewielki ułamek tej kwoty.

3. **Zacommituj katalogi skilli.** Zacommituj `.agents/skills/`, `.claude/skills/` (dowiązania symboliczne do `.agents/skills/`, gdy celujesz w kilku agentów), `skills-lock.json` oraz `.claude/settings.json` przy instalacji pluginu. Wtedy zestaw skilli zespołu zmienia pull request, a nie wiadomość na czacie.

4. **Wypróbuj każdy skill raz na prawdziwej pracy.** Użyj promptów poniżej. `grill-me` wywołuje tylko użytkownik, więc nigdy nie uruchomi się sam; `tdd` i `find-skills` model wywołuje na podstawie ich opisów.

**Prompt do skopiowania: znajdź skill, zanim go napiszesz**

```text
Use the find-skills skill. I want a skill that makes you reproduce a bug with a failing
test before you change any code. Search for candidates, show each one's owner, install
count and what its SKILL.md instructs, and recommend one. Prefer repositories owned by
mattpocock, obra, anthropics or vercel-labs. Show me the npx skills add command with
--skill <name> (not --skill=<name>) and do not run it until I approve.
```

**Prompt do skopiowania: przepytanie przed jakimkolwiek kodem**

```text
/grill-me We need per-seat billing on the team plan: adding a seat mid-cycle is prorated,
removing one takes effect at renewal. Interview me one question at a time until every
branch of this is decided: who owns the seat count, what happens on failed payment, what
the invoice shows. Write no code. At the end, list the decisions we made.
```

Czego się spodziewać: agent zadaje jedno pytanie, czeka i idzie za gałęzią, którą otwiera twoja odpowiedź, na przykład pyta o zaokrąglanie proporcji po twojej odpowiedzi o dodawaniu miejsca w trakcie cyklu. Z zainstalowanym `tdd` prośba „fix the rounding bug in invoice totals test-first” sprawia, że agent podaje szew, który przetestuje, pisze jeden nieprzechodzący test, uruchamia go na czerwono, a potem pisze minimum kodu, żeby przeszedł.

## Jak połączyć skille praktyk w pętlę bez frameworka?

Framework taki jak Superpowers albo [pakiet dyscypliny](/pl/ecosystem/frameworks/discipline-packs/) daje stały proces. Większość korzyści dostaniesz z pięciu pojedynczych skilli, które łączysz sam, z twardą bramką przy każdym przekazaniu. Pętla wygląda tak: **grill → to-spec → tdd → verification-before-completion → code-review**.

Najpierw zainstaluj dodatkowe skille. `to-spec` i `code-review` Pococka potrzebują `setup-matt-pocock-skills`, który zapisuje twój tracker zadań (domyślnie GitHub albo lokalne pliki markdown) i etykiety triage:

```bash
# Codex shown; for Cursor swap -a codex for -a cursor.
npx skills add mattpocock/skills --skill to-spec code-review setup-matt-pocock-skills -a codex -y
npx skills add obra/superpowers --skill verification-before-completion -a codex -y

# Claude Code with the mattpocock-skills plugin: only the Superpowers skill is missing.
npx skills add obra/superpowers --skill verification-before-completion -a claude-code -y
```

1. **Przepytanie.** Uruchom `grill-me` (albo `grill-with-docs` w bazie kodu, której słownictwo agent wciąż myli). Kryterium wyjścia to lista uzgodnionych decyzji, a nie poczucie, że plan jest jasny.

2. **Specyfikacja.** Raz na repozytorium uruchom `/setup-matt-pocock-skills`, potem w tej samej sesji `/to-spec`. `to-spec` nie przepytuje ponownie. Proponuje szwy testowe (ang. seam: publiczna granica, na której testujesz zachowanie), prosi o ich potwierdzenie i publikuje w trackerze specyfikację z historyjkami użytkownika i etykietą `ready-for-agent`. Potwierdzone szwy testowe to to, co testuje następny etap.

3. **Najpierw test.** Poproś o implementację zaczynając od testów. `tdd` pisze jeden nieprzechodzący test na uzgodnionym szwie testowym, doprowadza go do zielonego i powtarza wycinek po wycinku. W obecnej wersji `tdd` refaktoryzacja należy do etapu review.

4. **Weryfikacja przed „gotowe”.** `verification-before-completion` uruchamia się, gdy agent ma ogłosić sukces. Jego reguła: żadnej deklaracji ukończenia bez świeżego wyniku polecenia, które ją dowodzi. Oczekuj, że agent uruchomi cały zestaw testów, sprawdzanie typów i linter oraz wklei wynik.

5. **Review.** Uruchom `code-review` Pococka względem punktu odgałęzienia. Działa na dwóch subagentach równolegle: jeden porównuje diff z twoimi udokumentowanymi standardami, drugi ze specyfikacją z kroku 2, i raportuje oba wyniki. Popraw to, co znajdzie, i wróć do kroku 4.

**Prompt do skopiowania: zamień przepytanie w specyfikację**

```text
/to-spec Use the decisions from this conversation. Propose the fewest test seams that
cover them, preferring existing public interfaces, and wait for me to confirm the seams
before you publish. Every user story must map to at least one seam.
```

**Prompt do skopiowania: implementacja według specyfikacji, najpierw test**

```text
Implement the spec we just published, test-first, one seam at a time. For each slice:
write one failing test, run it and show me the failure, write the minimum code, run it
green. Run the type check after every slice. Before you tell me anything is done, run
the full test suite, the type check and the linter, and paste the exit codes.
```

**Prompt do skopiowania: review w dwóch osiach przed pull requestem**

```text
Use the code-review skill against main. Check the diff against our documented coding
standards and against the spec issue we published. Report findings side by side, with
severity. Do not fix anything yet; list what would change and why.
```

**Claude Code**

Z pluginem etapy to `/mattpocock-skills:grill-me`, `/mattpocock-skills:to-spec` i `/mattpocock-skills:code-review`. Wbudowany przegląd poprawności od Anthropic pozostaje pod `/code-review`, więc możesz uruchomić oba. Przy przenośnej kopii oba skille mają tę samą nazwę, więc zainstaluj skille Pococka jako plugin albo zmień nazwę katalogu przenośnej kopii i jej pola `name:` (na przykład na `spec-review`). Dodaj `/verify` po kroku 4, gdy zmianę widać w działającej aplikacji.

**Codex**

Etapy to `$grill-me`, `$to-spec`, potem zwykła prośba o pracę zaczynając od testów (`tdd` model wywołuje sam) i `$code-review`. Przed otwarciem pull requesta dodaj drugi, niezależny przegląd wbudowanym w Codeksie poleceniem `/review`.

**Cursor**

Etapy to `/grill-me`, `/to-spec`, prośba o pracę zaczynając od testów, potem `/code-review`. Etapy 1 i 2 prowadź w jednym czacie Agenta, bo `to-spec` syntetyzuje rozmowę, w której go uruchamiasz.

## Jak udowodnić, że pętla dała działający kod?

Skille zmieniają zachowanie agenta, ale niczego nie wymuszają. `verification-before-completion` każe agentowi pokazać dowód, ale skill można pominąć, a agent może źle odczytać wynik. Dlatego dowód leży poza agentem:

- **CI jest bramką.** Te same polecenia testów, typów i lintera, których wynik agent wkleił, uruchamiają się ponownie w CI na pull requeście. Czerwone CI unieważnia każde „gotowe” z czatu.
- **Specyfikacja jest wyrocznią.** Każda historyjka z `to-spec` ma swój szew, a każdy szew test, który najpierw nie przechodził, a potem przeszedł. Recenzent sprawdza to przyporządkowanie, a nie każdą linię. Strona o [pakiecie dowodów](/pl/workflows/ship/evidence-bundle/) pokazuje, jak dołączyć go do pull requesta.
- **Drugi recenzent z innymi martwymi punktami.** `code-review` Pococka sprawdza specyfikację i standardy; wbudowane w Claude Code `/code-review` oraz `/review` w Codeksie sprawdzają poprawność. Przy ryzykownych zmianach uruchom oba.
- **Skille też się ewaluuje.** Zanim ustandaryzujesz skill w zespole, zmierz, czy się uruchamia: `skill-creator` uruchamia przypadki testowe ze skillem i bez niego, a w Claude Code `claude plugin eval` uruchamia zestaw ewaluacji pluginu względem przebiegu bez pluginu.

Za dowody odpowiada developer, który otwiera pull request. Tech lead odpowiada za zacommitowany zestaw skilli i zatwierdza jego zmiany przez review, jak każdy inny kod.

## Dodaj konwencje zespołu jako skill projektu

Skille społeczności nie znają twoich nazw gałęzi ani tego, kto recenzuje co. Zapisz to w jednym skillu projektu, obok zainstalowanych skilli:

**Claude Code**

Utwórz `.claude/skills/team-conventions/SKILL.md` z polem `name`, polem `description`, które mówi, kiedy go użyć (na przykład „Use when creating a branch, commit or pull request”), i regułami w treści.

**Codex**

Utwórz `.agents/skills/team-conventions/SKILL.md` z tym samym frontmatterem i treścią. To katalog projektu, którego CLI skills używa dla Codeksa.

**Cursor**

Utwórz `.agents/skills/team-conventions/SKILL.md` z tym samym frontmatterem i treścią, żeby Codex i Cursor dzieliły jedną kopię.

Typowe reguły: format nazw gałęzi (`type/TEAM-123-description`), który zespół recenzuje którą ścieżkę, jak merge trafia na produkcję i gdzie ogłaszać wydanie. Frontmatter i ewaluację szczegółowo opisuje strona o [budowaniu własnych skilli](/pl/ecosystem/skills/building-custom-skills/).

**Prompt do skopiowania: wyciągnij konwencje do skilla**

```text
Read the last 50 commit messages, the last 20 merged pull request descriptions and the
README files in this repository. Identify the recurring conventions: commit message
format, pull request structure, branch naming, and who reviews which paths. Draft a
SKILL.md named team-conventions whose description says it applies when creating a
branch, commit or pull request. Quote the evidence for each rule. Show me the draft
before you write the file.
```

**Pułapki przy instalowaniu skilli praktyk**

- **`--skill=<name>` jest po cichu ignorowane** przez CLI skills 1.7.0. Bez `-y` dostajesz interaktywny wybór; z `-y` instalujesz wszystkie skille z repozytorium. Pisz `--skill grill-me` albo `mattpocock/skills@grill-me`.
- **`--skill` dopasowuje pole `name` z frontmattera, nie nazwę katalogu.** Katalog `react-best-practices` zawiera skill `vercel-react-best-practices`.
- **Delegat zainstalowany sam nic nie robi.** Instaluj `grilling` razem z `grill-me`, a `codebase-design` razem z `tdd`.
- **`npx skills add obra/superpowers` to nie plugin Superpowers.** Przenośna kopia nie ma bootstrapu uruchamianego na starcie sesji, więc metodyka nie włącza się sama. Pełny workflow daje `/plugin install superpowers@claude-plugins-official`.
- **`/code-review` oznacza w Claude Code dwie różne rzeczy.** Wbudowany skill zajmuje samą nazwę; plugin `code-review` od Anthropic działa jako `/code-review:code-review`; skill z pluginu Pococka działa jako `/mattpocock-skills:code-review`. Przenośna kopia `code-review` Pococka ma tę samą nazwę co wbudowany skill, więc użyj pluginu albo zmień nazwę kopii.
- **Dwa skille TDD się gryzą.** `tdd` Pococka najpierw uzgadnia szwy testowe i zostawia refaktoryzację na review; `test-driven-development` z Superpowers to ścisła pętla red-green-refactor. Zainstaluj jeden.

## Co się psuje, gdy łączysz wiele skilli praktyk?

**Agent jest zbyt metodyczny przy poprawce w jednej linii.** Przepytanie i specyfikacja to narzut przy literówce. Powiedz to wprost: „This is a mechanical one-line fix: skip grilling and the spec, but run the targeted test and paste the output.” Krótka prośba sama nie wyłącza skilla wywoływanego przez model.

**Weryfikacja staje na testach, które były czerwone od początku.** Przed startem zapisz nieprzechodzący punkt wyjścia, a potem oddzielaj zaakceptowane czerwone testy od nowej regresji. Nie pozwól agentowi ponawiać, aż będzie zielono, ani pomijać pliku z testami bez spisanej polityki zespołu.

**Sesje robią się wolne i drogie.** Każdy zainstalowany skill kosztuje swój wpis na liście w każdej sesji, a treść kosztuje tokeny przy każdym uruchomieniu. Usuń to, co przez tydzień się nie uruchomiło: `npx skills remove <name>`, a potem porównaj `/context` w Claude Code przed i po.

**Równoległe sesje wchodzą sobie w drogę.** Dwóch agentów z tym samym workflow w jednym checkoucie dzieli pliki i stan. Daj każdej sesji osobny worktree; przygotuje go `using-git-worktrees` albo flaga worktree twojego agenta.

**`find-skills` zwraca długą, zaszumioną listę.** Nazwij praktykę i stos: „a skill for Playwright end-to-end tests in a Next.js app” działa lepiej niż „testing skills”. Potem przeczytaj proponowany `SKILL.md`, zanim zatwierdzisz instalację.

**Skill po zmianie nazwy nie chce się zainstalować.** `to-prd`, `to-issues` i `diagnose` wciąż pojawiają się w starych wpisach i rankingach. Uruchom `npx skills add mattpocock/skills --list`, żeby zobaczyć obecne nazwy.

Skille dostawców do monitoringu, potoków danych i platform, które są poza tym rankingiem, znajdziesz w [oficjalnych skillach od twórców technologii](/pl/ecosystem/skills/top-skills-official/).

## Dokąd dalej ze skillami praktyk

- [Instalowanie i zarządzanie skillami](/pl/ecosystem/skills/installing-managing/) — Zasięgi, aktualizacje i usuwanie przez CLI skills, dla każdego agenta.
- [Grill Me i Grill With Docs](/pl/ecosystem/skills/grill-me/) — Etap uzgadniania z tej pętli, szczegółowo.
- [Superpowers](/pl/ecosystem/frameworks/superpowers/) — Gdy chcesz cały proces jako jeden plugin zamiast pięciu skilli.
- [Bezpieczeństwo łańcucha dostaw skilli](/pl/ecosystem/skills/skill-security/) — Co przeczytać, zanim jakikolwiek zewnętrzny skill zadziała w twoim repo.
