# AI Developer Toolkit (Polski)

> Inżynieria agentowa z Cursorem, Claude Code i Codeksem: sprawdź, na którym poziomie drabiny autonomii (0–5) jest Twój workflow, i wejdź o jeden wyżej. 400+ przewodników o konfiguracji, harnessie (CLAUDE.md, AGENTS.md, reguły, MCP), pętlach, weryfikacji i wydawaniu.

AI Developer Toolkit (developertoolkit.ai) to platforma edukacyjna dla profesjonalnych programistów, sprzedawana jako płatność jednorazowa za 12 miesięcy dostępu, bez subskrypcji. Treści są dwujęzyczne (po angielsku i po polsku) — sekcje /pl/start/ oraz /pl/ladder/ są darmowe i nie wymagają konta.

## Produkt i autor

- [Cennik](https://developertoolkit.ai/pl/pricing/): Toolkit za 249,99 zł jednorazowo: Setup Pack pod twój stack, 12 miesięcy dostępu do 400+ przewodników i osiem książek. Nic się samo nie odnawia.
- [Dla zespołów](https://developertoolkit.ai/pl/services/): Do 8 programistów, jedno repozytorium, jedno narzędzie. Konfiguracja agenta, szablon zadania, zasady testowania i checklista review zostają w repo.
- [Setup Pack](https://developertoolkit.ai/pl/setup-pack/): Dziewięć pytań i masz CLAUDE.md, AGENTS.md, reguły Cursora, konfigurację MCP i TESTING.md — ruch z poziomu 2 na 3, wygenerowany pod twój stack, do wdrożenia w około 20 minut.
- [Książki](https://developertoolkit.ai/pl/books/): Wszystkie osiem książek: Podręcznik, książki o Cursorze, Claude Code i Codeksie oraz cztery ścieżki dla ról. EPUB i PDF, po polsku i angielsku, w cenie Toolkitu.
- [Przykłady](https://developertoolkit.ai/pl/examples/): Jedno omówienie łańcucha artefaktów, a potem przepisy: frontend, backend, bazy, DevOps i mobile.
- [Spis treści](https://developertoolkit.ai/pl/contents/): Ponad 400 przewodników w jednej liście: Cursor, Claude Code, Codex, Drabina, MCP, Skills, workflowy i cookbook.
- [O nas](https://developertoolkit.ai/pl/about/): Kto pisze AI Developer Toolkit i po co: drabina od autouzupełniania AI do fabryki oprogramowania, w Claude Code, Codeksie i Cursorze — od CTO, który dowozi z agentami.
- [Scorecard developera](https://developertoolkit.ai/pl/scorecard/): Darmowy scorecard z 25 pytań, który umieszcza cię na drabinie autonomii, poziomy 1–4 — i wskazuje jeden ruch o szczebel wyżej.
- [Scorecard tech leada](https://developertoolkit.ai/pl/lead-scorecard/): Darmowy scorecard z 25 pytań dla tech leadów: poziom, na którym dowozi cały zespół, w sześciu wymiarach — plus plan 30/60/90 na szczebel wyżej.
- [Scorecard dla C-Level](https://developertoolkit.ai/pl/cto-scorecard/): Darmowy scorecard z 25 pytań o poziom organizacji — adopcja i wydatki, wspólna infrastruktura, bramki jakości, równoległość, ROI — plus plan 30/60/90 i rejestr ryzyk.
- [MCP](https://developertoolkit.ai/pl/mcp/): Publiczny endpoint Model Context Protocol nad 1100+ przewodnikami o Cursorze, Claude Code i Codeksie. Dwa narzędzia: search i fetch.
- [Co nowego](https://developertoolkit.ai/pl/whats-new/): Fabryki oprogramowania, floty agentów z herdr i tmuxem, przycinanie CLAUDE.md i AGENTS.md, audyt tego, co ładuje twój agent.
- [Społeczność](https://developertoolkit.ai/pl/community/): Discord z pytaniami o przewodniki i publiczne repozytorium na GitHubie, gdzie zgłosisz błąd.
- [Kontakt](https://developertoolkit.ai/pl/contact/): Pytania, pomoc techniczna i zapytania zespołów. Warszawa, Polska — support@developertoolkit.ai

## Autonomy Ladder (free, no account required)

- [Drabina autonomii: na którym poziomie pracujesz?](https://developertoolkit.ai/pl/ladder/): Sześciopoziomowa skala Dana Shapiro: ile kodu piszą agenci, a ile czytają ludzie. Test, który umieszcza każdą pętlę na szczeblu, i poradniki do każdego poziomu.
- [Twój warsztat i kariera, gdy kod piszą agenci](https://developertoolkit.ai/pl/ladder/craft-and-career/): Które umiejętności inżyniera zyskują, a które słabną, gdy kod piszą agenci, paradoks nadzoru i plan portfolio na każdy poziom drabiny autonomii.
- [Czytanie dowodów zamiast kodu](https://developertoolkit.ai/pl/ladder/evidence-not-diffs/): Co czytać zamiast diffa agenta: zmianę specyfikacji, wyniki akceptacji, siłę wyroczni i sygnały z działania oraz zmiany, w których człowiek wciąż czyta kod.
- [Poziom 1–2: kodowanie z asystą i w parze](https://developertoolkit.ai/pl/ladder/level-1-2-assisted-paired/): Poziomy 1 i 2 drabiny autonomii: jak rozpoznać poziom 2 i zestaw na każde narzędzie (plik kontekstu, bramka planu, sprawdzona pętla), który wynosi repo wyżej.
- [Poziom 3: przeglądasz diffy](https://developertoolkit.ai/pl/ladder/level-3-review-diffs/): Poziom 3 drabiny autonomii: agenci piszą równolegle, a ty czytasz każdy diff. Jak go prowadzić, dlaczego sufitem jest review i jak przejść na dowody.
- [Poziom 4: piszesz specyfikacje](https://developertoolkit.ai/pl/ladder/level-4-write-specs/): Poziom 4 drabiny autonomii: piszesz specyfikację, warunek stopu i wyrocznię, a agent pracuje godzinami. Konfiguracja w Claude Code, Codeksie i Cursorze.
- [Poziom 5: prowadzisz fabrykę oprogramowania](https://developertoolkit.ai/pl/ladder/level-5-run-the-factory/): Poziom 5 drabiny autonomii: sześć stanowisk fabryki w Claude Code, Codeksie i Cursorze oraz test, które pętle mogą działać bez nadzoru.
- [Jedna mapa: drabina autonomii, cykl życia i stacje fabryki](https://developertoolkit.ai/pl/ladder/one-map/): Jedna siatka dla drabiny autonomii (L0–L5 na pętlę), sześciu etapów cyklu życia i sześciu stacji fabryki, z dowodami, których wymaga każda komórka.
- [Stan inżynierii agentowej, wrzesień 2026](https://developertoolkit.ai/pl/ladder/state-of-agentic-engineering-2026/): Ile kodu piszą agenci w 2026 roku, gdzie kończy się drabina autonomii i dlaczego granicą jest weryfikacja. Tylko zewnętrzne dowody, każda liczba z datą.
- [Co zostaje człowiekowi w inżynierii agentowej](https://developertoolkit.ai/pl/ladder/the-humans-job/): Sześć decyzji, które zostają przy człowieku, gdy kod piszą agenci: jak zapisać właściciela każdej pętli i udowodnić, że decyzje nadal obowiązują.
- [Vibe coding a inżynieria agentowa: 21 pojęć porównanych](https://developertoolkit.ai/pl/ladder/vibe-coding-vs-agentic-engineering/): 21 pojęć z pracy z AI zestawionych z vibe codingiem: kto je nazwał i kiedy, kto pisze kod, kto go sprawdza i czym się różnią. Każdy cytat z datą i linkiem.

## Start here (free, no account required)

- [Zacznij tutaj: wybierz swoją ścieżkę przez inżynierię agentową](https://developertoolkit.ai/pl/start/): Od czego zacząć w AI Developer Toolkit: szybki start w Cursorze, Claude Code albo Codeksie lub ścieżka czytania dla twojej roli.
- [Ścieżka CTO i VP Engineering: model operacyjny dla oprogramowania budowanego przez agentów](https://developertoolkit.ai/pl/start/cto/): Ścieżka czytania dla CTO: dziesięć decyzji w ustalonej kolejności, od dowodów i pilotażu po autonomię, bezpieczeństwo, koszty, regulacje i raport dla zarządu.
- [Ścieżka dewelopera: plan czytania do inżynierii agentowej](https://developertoolkit.ai/pl/start/developer/): Ścieżka czytania dla programistów: od drabiny autonomii i szybkiego startu narzędzia do specyfikacji, pętli testów i oceniania dowodów zamiast diffów.
- [Ścieżka dla zarządu: brief na dziesięć minut i pięć decyzji, które należą do ciebie](https://developertoolkit.ai/pl/start/executive/): Dla zarządu: co agenci kodujący zmieniają w kosztach, tempie i ryzyku, datowane dowody z obu stron i pięć decyzji, które należą do kierownictwa.
- [Triki dla zaawansowanych: Cursor, Claude Code i Codex](https://developertoolkit.ai/pl/start/power-user-tips/): Najcenniejsze triki do Claude Code, Codeksa i Cursora, po jednej linii, sprawdzone 26.09.2026, każdy z linkiem do strony narzędzia, która go objaśnia.
- [Szybkie efekty w pierwszych 24 godzinach](https://developertoolkit.ai/pl/start/quick-wins/): Dziesięć technik na pierwszy dzień z Claude Code, Codeksem i Cursorem: prompt do skopiowania i test, który potwierdza wynik bez czytania każdej linii.
- [Ścieżka tech leada: cały zespół o szczebel wyżej](https://developertoolkit.ai/pl/start/tech-lead/): Ścieżka czytania dla tech leada: wspólny harness agentów, projekt weryfikacji i przepustowość code review, krok po kroku według pytań scorecardu
- [Dlaczego narzędzia AI do kodowania? Od autouzupełniania do inżynierii agentowej](https://developertoolkit.ai/pl/start/why-ai-coding-tools/): Dlaczego narzędzia AI do kodowania zmieniły pracę: kod piszą agenci, a ty specyfikujesz zachowanie i sprawdzasz je testami. Inżynieria agentowa w skrócie.

## Cursor

- [Cursor IDE: edytor kodu AI](https://developertoolkit.ai/pl/cursor-ide/): Zacznij tu z Cursorem: która powierzchnia pasuje do zadania, jak zmiana idzie od planu do scalonego PR i jak dowieść, że działa, bez czytania każdego diffa.
- [Automatyzacja Cursora: wybierz mechanizm, potem udowodnij wynik](https://developertoolkit.ai/pl/cursor-ide/automate/): Cursor bez nadzoru: reguły, własne serwery MCP, CLI w CI, Cloud Agents z Automations i SDK oraz weryfikacja każdego przebiegu bez czytania diffów.
- [Zaawansowane techniki w Cursorze: wskazówki 91-105](https://developertoolkit.ai/pl/cursor-ide/automate/advanced-techniques/): 15 zaawansowanych wskazówek do Cursora: MCP tylko do odczytu, specyfikacje dla Cloud Agents, hook stop z bramkami, warstwowy review i kontrola kosztów.
- [Skrypty z Cursor CLI: git hooki, review w CI i zadania cykliczne](https://developertoolkit.ai/pl/cursor-ide/automate/automation-workflows/): Headless agent Cursora (agent -p) w hooku pre-commit, review PR w GitHub Actions i cotygodniowym zadaniu, z deterministycznymi bramkami dowodzącymi wyniku.
- [Cloud Agents i Automations: hala produkcyjna Cursora](https://developertoolkit.ai/pl/cursor-ide/automate/cloud-agents-automations/): Uruchamiaj cloud agents Cursora bez nadzoru przez Automations: wyzwalacz, narzędzia i repozytoria, weryfikacja PR-ów oraz awarie, które kosztują.
- [Cursor SDK i Cloud Agents API](https://developertoolkit.ai/pl/cursor-ide/automate/cursor-sdk/): Uruchamiaj i śledź cloud agentów Cursora ze skryptów i CI przez @cursor/sdk 1.0.32 i Cloud Agents API, z workflow otwierającym PR, gdy main pada.
- [Własny serwer MCP zbudowany przez agenta Cursora](https://developertoolkit.ai/pl/cursor-ide/automate/custom-mcp-servers/): Agent Cursora buduje serwer MCP tylko do odczytu dla Postgresa na SDK TypeScript v2; sprawdzasz go Inspectorem i testami, a potem rejestrujesz w mcp.json.
- [Własne reguły i szablony w Cursorze](https://developertoolkit.ai/pl/cursor-ide/automate/custom-rules-templates/): Rozbuduj .cursor/rules/ w testowaną bibliotekę: dobierz tryb ładowania, stwórz szablony zadań, udostępnij ją przez Team Rules lub pluginy i sprawdź działanie.
- [Budowanie z Cursorem: od czatu z agentem do sprawdzonej zmiany](https://developertoolkit.ai/pl/cursor-ide/build/): 22 przewodniki po budowaniu w Cursorze dla programistów i tech leadów: funkcje edytora, czat z agentem, agenci równolegli i scenariusze z dowodami.
- [Praca z czatem agenta w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/agent-chat/): Czat agenta Cursora od prośby do udowodnionej zmiany: testy jako definicja ukończenia, bramki w prompcie, raport z dowodami i moment na restart.
- [Tryby agenta w Cursorze: kiedy planować, pytać, budować i debugować](https://developertoolkit.ai/pl/cursor-ide/build/agent-modes-deep-dive/): Dobierz tryb agenta Cursora do etapu zadania: Plan Mode przed edycją, Agent mode z bramkami jakości, a przebieg tylko do odczytu lub debugowanie po dowody.
- [Okno Agents w Cursorze: równoległe agenty](https://developertoolkit.ai/pl/cursor-ide/build/agents-window/): Uruchamiaj kilka agentów Cursora równolegle z okna Agents, daj każdemu osobny checkout i kartę zadania, a scalaj tylko to, co ma własne dowody.
- [Budowanie integracji API z agentem Cursora](https://developertoolkit.ai/pl/cursor-ide/build/api-integration/): Integracje ze Stripe, SendGrid i Twilio z agentem Cursora: najpierw testy, potem ponowienia, idempotencja, podpisane webhooki i bramki dowodzące działania.
- [Checkpointy i gałęzie: bezpieczne cofanie zmian agenta Cursora](https://developertoolkit.ai/pl/cursor-ide/build/checkpoints-branching/): Łącz checkpointy Cursora z gałęziami i commitami Gita, by cofnąć jedną turę agenta, plik lub cały eksperyment i zostawić tylko sprawdzone zmiany.
- [Podstawowe funkcje Cursora: dobierz narzędzie i sprawdź wynik](https://developertoolkit.ai/pl/cursor-ide/build/core-features/): 15 codziennych funkcji Cursora (Tab, edycja inline, tryby agenta, kontekst @, checkpointy, Bugbot), każda z kontrolą, która potwierdza jej wynik.
- [Budowanie pipeline'u danych z Cursorem](https://developertoolkit.ai/pl/cursor-ide/build/data-pipeline/): Pipeline ETL z agentem Cursora: kontrakt z Plan Mode, testy na fixture'ach chronione przed edycją przez agenta, idempotentne ładowanie i uzgadnianie ze źródłem.
- [Generowanie i weryfikacja dokumentacji z agentem Cursora](https://developertoolkit.ai/pl/cursor-ide/build/documentation/): Agent Cursora pisze TSDoc, przewodniki, diagramy Mermaid i przewodnik migracji z Twojego kodu, a bramki CI sprawdzają je zamiast ręcznej korekty.
- [Budowanie UI z projektów w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/frontend-ui/): Zamieniaj ramki z Figmy w komponenty React agentem Cursora, przypnij tokeny w regule i udowodnij zgodność zrzutami Playwright oraz skanem axe.
- [Edycja inline w Cursorze: wskazówki 46–60](https://developertoolkit.ai/pl/cursor-ide/build/inline-edit/): Wyznacz zakres edycji inline w Cursorze zaznaczeniem, pisz instrukcje trafiające za pierwszym razem, łącz małe edycje i sprawdzaj każdą typami i testami.
- [Strategie dla dużych baz kodu w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/large-codebase-strategies/): Jak utrzymać celność agenta Cursora w dużym repo i monorepo: otwórz jeden pakiet, odfiltruj szum, zawęź reguły, planuj zmiany i weryfikuj bramkami.
- [Refaktoryzacja kodu legacy w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/legacy-refactor/): Refaktoryzuj nieprzetestowany kod legacy z agentem Cursora: utrwal zachowanie testami charakteryzacyjnymi, zmieniaj jedno miejsce na commit, udowodnij wynik.
- [Mikroserwisy w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/microservices/): Mikroserwisy z Agentem Cursora: reguły topologii, granice w Plan Mode, kontrakt przed kodem z bramką lint i oasdiff, szkielety na wzór sprawdzonego serwisu.
- [Migracja frameworków w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/migration/): Migracja frameworków i wersji głównych w Cursorze: inwentaryzacja w Plan Mode, najpierw codemody, partie agenta z zablokowanymi testami i zapadka w CI.
- [Tworzenie aplikacji mobilnych w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/mobile-dev/): Buduj ekrany React Native agentem Cursora: reguła mobilna, serwery MCP dla symulatorów oraz bramki i zrzuty z obu platform jako dowód każdej zmiany.
- [Praca z wieloma repozytoriami w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/multi-repo-workflows/): Praca na kilku repozytoriach w Cursorze: workspace z wieloma folderami, reguły własności, GitHub MCP tylko do odczytu i zmiany od kontraktu z bramkami CI.
- [Pair programming z agentem Cursora](https://developertoolkit.ai/pl/cursor-ide/build/pair-programming/): Programuj w parze z agentem Cursora: projekt w Plan Mode, wycinki budowane od testu, debugowanie od dowodów i weryfikacja każdego kroku poleceniem.
- [Szablony promptów dla agenta Cursora](https://developertoolkit.ai/pl/cursor-ide/build/prompt-templates/): Gotowe szablony promptów dla Cursora: funkcje, błędy, refaktoryzacja, testy i przegląd, każdy z krokiem weryfikacji, zapisany jako Agent Skill lub reguła.
- [Strategie refaktoryzacji w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/refactoring-strategies/): Dziel, przemianowuj i przebudowuj przetestowany kod agentem Cursora małymi krokami, z bramkami, które dowodzą, że zachowanie się nie zmieniło.
- [Zarządzanie snippetami w Cursorze](https://developertoolkit.ai/pl/cursor-ide/build/snippet-management/): Podziel boilerplate w Cursorze między snippety VS Code, reguły i prompty agenta, a w CI sprawdzaj, że szkielety się kompilują i nie rozjeżdżają z kodem.
- [Cursor Tab: trafne edycje wieloliniowe i ich weryfikacja](https://developertoolkit.ai/pl/cursor-ide/build/tab-autocomplete/): Wieloliniowe edycje z Cursor Tab, którym da się ufać: podsuń wzorzec, szybko przyjmuj lub odrzucaj, a przyjęty kod sprawdzą typy, testy i linter.
- [Oszczędności czasu w Cursorze przy codziennych obowiązkach](https://developertoolkit.ai/pl/cursor-ide/build/time-savers/): Oddaj Cursorowi powtarzalne zadania (komentarze, commity, zmiany masowe, brakujące testy, poprawki przed pushem), każde z automatyczną kontrolą wyniku.
- [Eksploatacja Cursora na produkcji](https://developertoolkit.ai/pl/cursor-ide/operate/): Który poradnik Cursora otworzyć przy kosztach tokenów, wolnym edytorze, wolnym kodzie, braku monitoringu lub audycie bezpieczeństwa i jak udowodnić poprawkę.
- [Konfiguracja logowania i monitoringu w Cursorze](https://developertoolkit.ai/pl/cursor-ide/operate/monitoring/): Agent Cursora generuje ustrukturyzowane logi, metryki Prometheusa, tracing OpenTelemetry i reguły alertów, a testy i promtool dowodzą, że każda warstwa działa.
- [Strojenie Cursora pod duże repozytoria](https://developertoolkit.ai/pl/cursor-ide/operate/performance-optimization/): Szybki Cursor w dużym repo: odchudź indeks przez .cursorignore, zrób audyt rozszerzeń, ogranicz watcher i wyszukiwanie, a każdą zmianę potwierdź pomiarem.
- [Optymalizacja wydajności aplikacji z Cursorem](https://developertoolkit.ai/pl/cursor-ide/operate/performance/): Najpierw pomiar, potem agent Cursora naprawia zapytania N+1, wagę bundla i re-rendery, a zysk potwierdzasz powtórką pomiaru, testami i budżetem w CI.
- [Audyt bezpieczeństwa w Cursorze: skanery, agent i bramki CI](https://developertoolkit.ai/pl/cursor-ide/operate/security/): Audyt bezpieczeństwa z Cursorem: najpierw skanery, potem przegląd agenta, test exploita dla każdego znaleziska i bramki CI, które pilnują poprawek.
- [Zarządzanie tokenami w Cursorze](https://developertoolkit.ai/pl/cursor-ide/operate/token-management/): Tnij zużycie tokenów w Cursorze bez utraty jakości: zawężaj reguły, skracaj czaty, dołączaj mniej i dowodź oszczędności danymi z SDK oraz logiem kompakcji.
- [Planowanie z Cursorem: zaakceptowany plan przed pierwszą linią kodu](https://developertoolkit.ai/pl/cursor-ide/plan/): Trzy przewodniki Cursora dla programistów i tech leadów: start projektu, schemat bazy danych i wybór architektury w Plan Mode, zanim agent coś zmieni.
- [Projektowanie architektury systemu z agentem Cursora](https://developertoolkit.ai/pl/cursor-ide/plan/architecture/): Zbadaj opcje w Plan Mode Cursora, zapisz decyzję jako ADR i egzekwuj ją regułą projektu oraz testami fitness w CI zamiast czytać każdy diff.
- [Projektowanie schematu bazy danych z Cursorem](https://developertoolkit.ai/pl/cursor-ide/plan/database-design/): Schemat Postgresa z agentem Cursora: najpierw uzgodniony model, potem Drizzle, a reguły, plany zapytań i migracje udowadniasz testami.
- [Nowy projekt z agentem Cursora](https://developertoolkit.ai/pl/cursor-ide/plan/new-project/): Od jednozdaniowego briefu do działającego szkieletu Next.js w Cursorze: PRD w Plan Mode, najpierw reguły, bramki z dowodem porażki, potem funkcja z testami.
- [Szybki start Cursora: od instalacji do pierwszej zweryfikowanej funkcji](https://developertoolkit.ai/pl/cursor-ide/quick-start/): Szybki start Cursora: instalacja, polecenie verify, tryby uruchamiania, reguły, MCP i Plan Mode, a potem funkcja dowiedziona testami, nie czytaniem diffu.
- [Kontrola wersji i współpraca zespołowa w Cursorze](https://developertoolkit.ai/pl/cursor-ide/quick-start/collaboration/): Agent Cursora pisze commity, rozwiązuje konflikty merge, otwiera i recenzuje PR-y, a polecenia gita dowodzą, że nic nie zginęło przed pushem.
- [Zarządzanie kontekstem w Cursorze](https://developertoolkit.ai/pl/cursor-ide/quick-start/context-management/): Daj agentowi Cursora właściwy kontekst: wzmianka @ o jednym wzorcowym pliku, granice zmiany, aktualna dokumentacja, przekazanie między czatami i dowód.
- [Debugowanie i odzyskiwanie po błędach](https://developertoolkit.ai/pl/cursor-ide/quick-start/error-handling/): Gdy agent Cursora zepsuje kod: cofnij zmiany checkpointem lub gitem, przerwij pętlę poprawek, wybierz naprawę albo restart i udowodnij wynik.
- [Podstawowa konfiguracja Cursora do pracy z agentem](https://developertoolkit.ai/pl/cursor-ide/quick-start/essential-configuration/): Skonfiguruj Cursora tak, by agent sam uruchamiał kontrole: polecenie verify, tryb uruchamiania, reguły projektu, hook stop i wykluczenia sekretów.
- [Zbuduj swoją pierwszą funkcję z pomocą AI](https://developertoolkit.ai/pl/cursor-ide/quick-start/first-feature/): Zbuduj wieloplikową funkcję z agentem Cursora: kryteria akceptacji, Plan Mode, małe kroki i dowód działania bez czytania każdej linii.
- [Instalacja Cursora i migracja z VS Code](https://developertoolkit.ai/pl/cursor-ide/quick-start/installation-setup/): Zainstaluj Cursora na macOS, Windows lub Linuksie menedżerem pakietów, przenieś konfigurację VS Code i sprawdź, czy agent widzi twój projekt.
- [Konfiguracja serwerów MCP w Cursorze](https://developertoolkit.ai/pl/cursor-ide/quick-start/mcp-setup/): Połącz agenta Cursora z GitHubem, Postgresem i przeglądarką przez .cursor/mcp.json, trzymaj tokeny poza gitem i sprawdzaj, że odpowiedź pochodzi z narzędzia.
- [Wybór modelu w Cursorze](https://developertoolkit.ai/pl/cursor-ide/quick-start/model-selection/): Jak dobrać model w Cursorze: zacznij od jednego mocnego modelu, najpierw zmieniaj wysiłek, a model zmieniaj dopiero po benchmarku na własnych testach.
- [Od PRD do planu i zadań w Cursorze](https://developertoolkit.ai/pl/cursor-ide/quick-start/prd-workflow/): Zamień PRD w ponumerowane kryteria akceptacji, plan z Plan Mode zapisany jako plan.md i po jednym zweryfikowanym zadaniu na czat w Cursorze.
- [Reguły projektu w Cursorze](https://developertoolkit.ai/pl/cursor-ide/quick-start/project-rules/): Napisz pierwsze reguły projektu Cursora w .cursor/rules/, dobierz tryb ładowania i sprawdź kanarkiem oraz zadaniem próbnym, że Agent ich przestrzega.
- [Bądź na bieżąco z Cursorem](https://developertoolkit.ai/pl/cursor-ide/reference/): Wiedz, jaki build Cursora i jakie SDK działa na każdej maszynie, czytaj wydania pod kątem swojej konfiguracji i wdrażaj aktualizacje za testami kanarkowymi.
- [Historia wersji Cursora](https://developertoolkit.ai/pl/cursor-ide/reference/changelog/): Wydania Cursora do października 2026: aktualna wersja i numeracja, wpisy changelogu od sierpnia, zmienione nazwy funkcji i procedura od noty wydania do przetestowanego wdrożenia w zespole.
- [Wdrażanie nowych funkcji Cursora](https://developertoolkit.ai/pl/cursor-ide/reference/feature-adoption/): Oceń zasięg nowej funkcji Cursora, przetestuj ją w worktree na scalonych zadaniach, udowodnij bramkami CI i dopiero wtedy zapisz w repozytorium.
- [Skróty klawiszowe Cursora: sprawdź, przypnij, połącz](https://developertoolkit.ai/pl/cursor-ide/reference/keyboard-shortcuts/): Sprawdź skróty AI Cursora we własnej wersji, przypnij je w keybindings.json, by aktualizacja ich nie przestawiła, i łącz w sprawdzalne przepływy.
- [Przewodniki aktualizacji Cursora](https://developertoolkit.ai/pl/cursor-ide/reference/upgrade-guides/): Aktualizuj Cursora bez utraty działającej konfiguracji, sprawdzaj nowy build względem zapisanego punktu odniesienia i wracaj do poprzedniego z kontrolą hasha.
- [Code review i wdrożenie z Cursorem](https://developertoolkit.ai/pl/cursor-ide/ship/): Zmiana z Cursora od diffa do produkcji: review przed pushem, Bugbot, bramki CI, zatwierdzanie według reguł i rollout, który da się wycofać.
- [Bugbot: wyuczone reguły i Autofix](https://developertoolkit.ai/pl/cursor-ide/ship/bugbot/): Skonfiguruj Bugbota w Cursorze, naucz go reguł z historii code review, ustal granice Autofixa i udowodnij, że ta warstwa łapie prawdziwe błędy.
- [Pipeline'y CI/CD z Cursorem](https://developertoolkit.ai/pl/cursor-ide/ship/ci-cd/): Generuj i debuguj pipeline'y GitHub Actions z Cursorem, uruchom w CI agenta SDK tylko do odczytu i sprawdzaj workflowy actionlintem, zizmorem i czerwonym runem.
- [Code review w Cursorze: review lokalne, triaż PR-ów i recenzent w CLI](https://developertoolkit.ai/pl/cursor-ide/ship/code-review/): Code review w Cursorze bez czytania każdej linii: Agent Review i /review-bugbot przed pushem, prompty do triażu PR-ów i recenzent w CLI tylko do odczytu.
- [Infrastruktura jako kod z Cursorem](https://developertoolkit.ai/pl/cursor-ide/ship/devops/): Generuj Terraform, Dockerfile i manifesty Kubernetes Agentem Cursora, oprzyj go na MCP do odczytu i potwierdzaj każdą zmianę checkovem oraz podsumowaniem planu.
- [Rollouts oraz PR Routing & Approval w Cursorze](https://developertoolkit.ai/pl/cursor-ide/ship/rollouts-and-approval/): Cursor zatwierdza pull requesty niskiego ryzyka według reguł: klasa ryzyka z CI, ruleset GitHuba decyduje o merge’u, ślad audytowy i bezpieczny rollout.
- [Cursor w zespole i firmie](https://developertoolkit.ai/pl/cursor-ide/team/): Wdróż Cursora w zespole we właściwej kolejności: przepływ danych, pytania do dostawcy, wspólna konfiguracja, bramka przed review i Cloud Agents.
- [Prywatność i bezpieczeństwo w Cursorze](https://developertoolkit.ai/pl/cursor-ide/team/privacy-security/): Bezpieczny Cursor w zespole: Privacy Mode, .cursorignore, tryby uruchamiania, strażnik oparty na hookach, akceptacja MCP i test w CI dla kontroli.
- [Współpraca zespołowa w Cursorze](https://developertoolkit.ai/pl/cursor-ide/team/team-collaboration/): Reguły Cursora, konfiguracja MCP i skille w repozytorium, bramki w CI i Bugbocie oraz onboarding, po którym agent nowej osoby działa jak agent zespołu.
- [Testowanie i debugowanie z Cursorem](https://developertoolkit.ai/pl/cursor-ide/test/): Testy od agenta Cursora, które łapią prawdziwe błędy, i naprawy bez pętli napraw-zepsuj-napraw: trzy przewodniki o testowaniu i debugowaniu w Cursorze.
- [Debugowanie z AI w Cursorze](https://developertoolkit.ai/pl/cursor-ide/test/bug-hunting/): Sporadyczne awarie i sytuacje wyścigu w Cursorze: zbadaj bez edycji, odtwórz nieprzechodzącym testem, napraw jedną przyczynę i udowodnij to dowodami.
- [Wzorce testowania w Cursorze](https://developertoolkit.ai/pl/cursor-ide/test/testing-patterns/): Prompty, dzięki którym agent Cursora pisze testy łapiące prawdziwe błędy w istniejącym kodzie: zestawy z zachowania, testy charakteryzacyjne, E2E i flaky.
- [Test-driven development w Cursorze](https://developertoolkit.ai/pl/cursor-ide/test/testing-tdd/): TDD z agentem Cursora: zatwierdzasz czerwone testy jako specyfikację, agent implementuje do zielonego bez ich zmiany, a testy mutacyjne sprawdzają zestaw.

## Claude Code

- [Claude Code](https://developertoolkit.ai/pl/claude-code/): Claude Code dla programistów i tech leadów: pierwsza zweryfikowana zmiana, wybór trybu uprawnień, dowód jakości i mapa przewodnika.
- [Automatyzacja Claude Code: wybierz powierzchnię, potem udowodnij wynik](https://developertoolkit.ai/pl/claude-code/automate/): Claude Code bez nadzoru: /goal, claude -p, hooki, agenci w tle, przepływy, routine’y i Agent SDK; każdy przebieg udowadniasz maszynowymi bramkami.
- [Zaawansowane techniki Claude Code](https://developertoolkit.ai/pl/claude-code/automate/advanced-techniques/): Steruj rozumowaniem przez effort, uruchom MCP za pierwszym razem, zbuduj własne narzędzie MCP, recenzuj każdy PR w CI i pracuj równolegle w worktree.
- [Claude Agent SDK: własni agenci na pętli Claude Code](https://developertoolkit.ai/pl/claude-code/automate/agent-sdk/): Pętla agenta Claude Code sterowana z Pythona lub TypeScriptu: narzędzia, uprawnienia, hooki, subagenci, MCP i sesje, z botem do triage'u CI jako przykładem.
- [Agent view: wiele sesji Claude Code w claude agents](https://developertoolkit.ai/pl/claude-code/automate/agent-view/): Uruchamiaj, obserwuj i weryfikuj równoległe sesje Claude Code w tle z dashboardu claude agents: izolacja w worktree i code review oparte na dowodach.
- [Skrypty z Claude Code: uruchomienia headless, potoki, cron i hooki git](https://developertoolkit.ai/pl/claude-code/automate/automation/): Uruchamiaj Claude Code bez nadzoru przez claude -p: wąskie uprawnienia, wynik JSON sprawdzany przez skrypt, potoki, skille, pre-commit, cron i limity kosztów.
- [Channels i Remote Control: sterowanie sesjami Claude Code z dowolnego miejsca](https://developertoolkit.ai/pl/claude-code/automate/channels-and-remote-control/): Steruj lokalną sesją Claude Code z telefonu przez Remote Control, przesyłaj do niej zdarzenia z CI i czatu przez kanały i wiedz, kiedy lepsza jest chmura.
- [Polecenia niestandardowe i skille w Claude Code](https://developertoolkit.ai/pl/claude-code/automate/custom-commands/): Zamień zespołowe checklisty w polecenia slash Claude Code: pliki skilli, argumenty, kto je uruchamia, pierwszeństwo, lint w CI i dowód, że działają.
- [Własne subagenty w Claude Code: wyspecjalizowani pomocnicy, których pracę da się sprawdzić](https://developertoolkit.ai/pl/claude-code/automate/custom-subagents/): Zdefiniuj subagenty Claude Code w .claude/agents/, ogranicz ich narzędzia i modele, uruchamiaj je równolegle w worktree, lintuj w CI i weryfikuj ich raporty.
- [Dynamiczne przepływy pracy i ultracode](https://developertoolkit.ai/pl/claude-code/automate/dynamic-workflows/): Audyty kodu, migracje i badania z weryfikacją krzyżową jako jeden skrypt przepływu pracy Claude Code, który uruchamia wielu subagentów i sprawdza ich wyniki.
- [Praca z celem: /goal w Claude Code](https://developertoolkit.ai/pl/claude-code/automate/goal-workflows/): Wyznacz Claude Code metę komendą /goal: pisz warunki, które ewaluator oceni, uruchamiaj cele bez nadzoru i udowadniaj wynik bez czytania każdego diffa.
- [Hooki Claude Code: zabezpieczenia, bramki i kontekst na żywo](https://developertoolkit.ai/pl/claude-code/automate/hooks-automation/): Hooki Claude Code, które blokują ryzykowne polecenia, chronią ścieżki, lintują każdą edycję i nie kończą pracy przy czerwonych testach. Z przypadkami testowymi.
- [Routines: przebiegi Claude Code z harmonogramu, z API i z GitHuba](https://developertoolkit.ai/pl/claude-code/automate/routines/): Claude Code bez nadzoru w chmurze: z harmonogramu, wywołania API lub zdarzenia GitHuba. Wyzwalacze, gałęzie claude/, ładunek fire i weryfikacja przebiegów.
- [Budowanie z Claude Code: od zatwierdzonego planu do udowodnionej zmiany](https://developertoolkit.ai/pl/claude-code/build/): Przewodniki Claude Code dla programistów i tech leadów: wdrażaj zatwierdzony plan małymi krokami, prowadź duże zmiany i potwierdzaj każdą bramkami jakości.
- [REST i GraphQL API w Claude Code](https://developertoolkit.ai/pl/claude-code/build/api-development/): API w Claude Code: kontrakt w trybie planowania, jeden zasób na iterację oraz bramki spec, fuzz i auth, które dowodzą, że działa.
- [Operacje wsadowe: jedna zmiana w setkach plików](https://developertoolkit.ai/pl/claude-code/build/batch-operations/): Jedna zmiana w setkach plików z Claude Code: najpierw plan, potem /batch albo skrypty claude -p, a wynik udowadniają bramki, nie czytanie diffów.
- [Linia poleceń Claude Code: sesje, flagi i jednorazowe potoki](https://developertoolkit.ai/pl/claude-code/build/command-line/): Wznawiaj i nazywaj sesje Claude Code, ustawiaj model, effort i tryb uprawnień przy starcie, a claude -p uruchamiaj w potokach z wynikiem do sprawdzenia.
- [Praca z bazą danych w Claude Code: schematy, migracje, zapytania i dane testowe](https://developertoolkit.ai/pl/claude-code/build/database-work/): Projektuj schematy, twórz pliki migracji, strój zapytania i generuj dane testowe z Claude Code, a każdą zmianę sprawdzaj na jednorazowej bazie przed CI.
- [Claude Code Desktop: sesje, worktree i code review w aplikacji](https://developertoolkit.ai/pl/claude-code/build/desktop-app/): Co aplikacja Claude Code Desktop dodaje do CLI: równoległe sesje w worktree, przegląd diffów, podgląd aplikacji, monitoring CI i wspólne ustawienia.
- [Generowanie i utrzymanie dokumentacji z Claude Code](https://developertoolkit.ai/pl/claude-code/build/documentation/): JSDoc, OpenAPI, README i dokumenty architektury generowane z kodu przez Claude Code i utrzymywane w zgodzie z nim dzięki hookom, lintom i kontroli w CI.
- [Triki wydajności w codziennej pracy z Claude Code](https://developertoolkit.ai/pl/claude-code/build/efficiency-hacks/): Nawyki w Claude Code, które oszczędzają czas bez pomijania kontroli: jedno zadanie na sesję, zawężony odczyt, skille zamiast promptów, JSON i bramka testów.
- [Co Claude Code potrafi, a czego jeszcze nie próbowałeś](https://developertoolkit.ai/pl/claude-code/build/features-you-havent-tried/): Około 30 niedocenianych funkcji Claude Code: importy w CLAUDE.md, blokada sekretów, /btw, /goal, /verify i hooki. Co naprawia każda i jak sprawdzić wynik.
- [Koordynacja IDE i CLI: Claude Code obok edytora](https://developertoolkit.ai/pl/claude-code/build/ide-coordination/): Claude Code CLI obok VS Code, Cursora, JetBrains lub Neovima: układy okien, jeden autor na plik, worktree i weryfikacja zmian w edytorze.
- [Od planu do działającego kodu w Claude Code](https://developertoolkit.ai/pl/claude-code/build/implementation/): Zamień zatwierdzony plan w zacommitowany kod z Claude Code: wycinki na jeden commit, bramki w hookach, dowody dla każdego wycinka i wznawianie między sesjami.
- [Integracje z zewnętrznymi API w Claude Code](https://developertoolkit.ai/pl/claude-code/build/integrations/): Buduj integracje ze Stripe, e-mailem, OAuth i webhookami w Claude Code, a potem udowodnij ich działanie odtwarzanymi zdarzeniami i testami podpisów.
- [Duże bazy kodu i monorepo w Claude Code: zakres, plan, weryfikacja](https://developertoolkit.ai/pl/claude-code/build/large-codebase/): Zawęź Claude Code do fragmentu dużego repo lub monorepo potrzebnego w zadaniu, zaplanuj zmiany między pakietami, izoluj pracę równoległą i sprawdzaj bramkami.
- [Pamięć Claude Code: CLAUDE.md, reguły i pamięć automatyczna](https://developertoolkit.ai/pl/claude-code/build/memory-system/): Skonfiguruj CLAUDE.md, reguły ze ścieżkami, importy i pamięć automatyczną w Claude Code, sprawdź, że działają, i utrzymuj je krótkie.
- [Migracje baz danych i kodu z Claude Code](https://developertoolkit.ai/pl/claude-code/build/migrations/): Zmiany schematu bez przestoju, aktualizacje frameworków i przejścia na nową wersję API z Claude Code: faza po fazie, każda sprawdzona bramką przed wdrożeniem.
- [Zmiany w wielu plikach](https://developertoolkit.ai/pl/claude-code/build/multi-file-workflows/): Jak przeprowadzić zmianę w dziesiątkach plików z Claude Code - plan zasięgu, kryteria akceptacji, /batch lub worktree i weryfikacja diffu.
- [Inżynieria promptów dla Claude Code](https://developertoolkit.ai/pl/claude-code/build/prompt-engineering/): Prompty dla Claude Code, które same się weryfikują: czteroczęściowy brief, warunek ukończenia, kontekst, tryb planowania, poziom effort i naprawa typowych błędów.
- [Wzorce refaktoryzacji w Claude Code](https://developertoolkit.ai/pl/claude-code/build/refactoring-patterns/): Refaktoryzacja modułu z Claude Code przy zablokowanych testach: Extract Function, polimorfizm, podział serwisu i async/await, dowodzone bramkami.
- [Refaktoryzacja na dużą skalę w Claude Code: zmień strukturę, udowodnij zachowanie](https://developertoolkit.ai/pl/claude-code/build/refactoring/): Przebuduj setki plików z Claude Code: przypnij zachowanie testami, zapisz strukturę jako regułę, dodaj hook Stop i udowodnij, że nic się nie zmieniło.
- [Komendy slash i skróty Claude Code według zadań](https://developertoolkit.ai/pl/claude-code/build/slash-commands-mastery/): Komendy slash i skróty Claude Code, które warto znać, pogrupowane według zadań: kontekst, rozgałęzianie, model, review i praca w tle, wraz z ich pułapkami.
- [Terminal dla Claude Code: tmux, powiadomienia i potoki](https://developertoolkit.ai/pl/claude-code/build/terminal-mastery/): Claude Code w tmux obok paneli testów i sprawdzania typów, alerty tylko wtedy, gdy agent na ciebie czeka, i błędy przekazywane do claude -p bez narzędzi.
- [Optymalizacja pracy z Claude Code: kolejka, pamięć, skille, weryfikacja](https://developertoolkit.ai/pl/claude-code/build/workflow-optimization/): Prowadź dzień pracy z Claude Code: steruj turą przez kolejkę, zachowaj kontekst między sesjami, zamień powtarzalne kroki w skille i udowodnij każdą zmianę.
- [Eksploatacja Claude Code na produkcji](https://developertoolkit.ai/pl/claude-code/operate/): Claude Code na co dzień: koszty w /usage i OpenTelemetry, zdrowe sesje, profilowanie tego, co agent wdraża, i audyt bezpieczeństwa.
- [Kontrola kosztów Claude Code w zespole](https://developertoolkit.ai/pl/claude-code/operate/cost-control/): Jak widzieć, przypisywać i ograniczać wydatki na Claude Code w zespole – /usage, OpenTelemetry, limity wydatków, limity budżetu i polityka modeli.
- [Konfiguracja obserwowalności z Claude Code](https://developertoolkit.ai/pl/claude-code/operate/monitoring/): Claude Code dodaje do usługi OpenTelemetry, logi strukturalne, testowane alerty i dashboardy, a hooki i subagent weryfikujący sprawdzają każdą zmianę.
- [Optymalizacja wydajności Claude Code: kontekst, cache i effort](https://developertoolkit.ai/pl/claude-code/operate/performance-optimization/): Tańsze i szybsze sesje Claude Code: zawęź kontekst, utrzymaj ciepły cache, dostrój effort przed zmianą modelu i udowodnij, że jakość się utrzymała.
- [Analiza wydajności aplikacji z Claude Code](https://developertoolkit.ai/pl/claude-code/operate/performance/): Znajdź przyczynę spowolnienia aplikacji z Claude Code: najpierw baseline, potem profiler, jedna poprawka i budżet wydajności, który dowodzi zysku.
- [Audyt bezpieczeństwa z Claude Code](https://developertoolkit.ai/pl/claude-code/operate/security-audit/): Audyt kodu z Claude Code: najpierw skanery deterministyczne, potem plugin Claude Security i /security-review, testy exploitów jako dowód i trwałe bramki.
- [Rozwiązywanie problemów z sesją Claude Code](https://developertoolkit.ai/pl/claude-code/operate/troubleshooting/): Napraw sesję Claude Code: reguły uprawnień, które nie działają, pomijany CLAUDE.md, martwe serwery MCP, dryf kontekstu, przerośnięte zmiany i dowód poprawki.
- [Planowanie z Claude Code: zatwierdzony plan przed pierwszą linią kodu](https://developertoolkit.ai/pl/claude-code/plan/): Cztery przewodniki Claude Code dla programistów i tech leadów: mapa bazy kodu, projekt funkcji, wybór architektury i start projektu w trybie planowania.
- [Analiza architektury i projektowanie systemów z Claude Code](https://developertoolkit.ai/pl/claude-code/plan/architecture/): Mapuj zależności, porównuj warianty projektu na własnym kodzie, pisz ADR-y i planuj migracje w trybie plan Claude Code, a każdą tezę sprawdzaj narzędziem.
- [Jak zrozumieć nieznany codebase z Claude Code](https://developertoolkit.ai/pl/claude-code/plan/codebase-analysis/): Zmapuj nieznane repozytorium z Claude Code w trybie planowania i z subagentami, a potem udowodnij mapę skryptem i testem, zanim zmienisz kod.
- [Planowanie funkcji w Claude Code: od jednozdaniowej prośby do zweryfikowanego planu](https://developertoolkit.ai/pl/claude-code/plan/feature-planning/): Zamień mglistą prośbę o funkcję w kryteria akceptacji i etapowy plan w plan mode Claude Code: wywiad, kryteria i audyt planu w świeżej sesji.
- [Nowy projekt z terminala w Claude Code](https://developertoolkit.ai/pl/claude-code/plan/project-init/): Bootstrap nowej usługi w Claude Code: zaplanuj szkielet, wygeneruj go i udowodnij, że działa – jednym skryptem verify, hookiem Stop i plikiem CLAUDE.md.
- [Szybki start Claude Code: od instalacji do pierwszej zweryfikowanej funkcji](https://developertoolkit.ai/pl/claude-code/quick-start/): Szybki start Claude Code dla programistów: instalacja, logowanie, uprawnienia, CLAUDE.md i pierwsza funkcja, którą dowodzą testy i review.
- [Uwierzytelnianie w Claude Code: subskrypcje, klucze API i dostawcy chmury](https://developertoolkit.ai/pl/claude-code/quick-start/authentication/): Zaloguj Claude Code planem Claude, kontem Console, przez dostawcę chmury lub tokenem CI i sprawdź w /status, które poświadczenie faktycznie płaci.
- [Konfiguracja Claude Code: ustawienia, uprawnienia i modele](https://developertoolkit.ai/pl/claude-code/quick-start/configuration/): Skonfiguruj pliki ustawień Claude Code, reguły i tryby uprawnień, sandbox, model i effort, a potem sprawdź wynik przez /status i /permissions.
- [Dogłębne rozumowanie w Claude Code: poziomy effort i rozszerzone myślenie](https://developertoolkit.ai/pl/claude-code/quick-start/deep-reasoning/): Ustal, jak mocno myśli Claude Code: poziomy effort, ultrathink, ultracode i tryb planowania, z promptami, bramkami weryfikacji i naprawą typowych błędów.
- [Zbuduj pierwszą funkcję z Claude Code](https://developertoolkit.ai/pl/claude-code/quick-start/development-workflow/): Jedna funkcja od ticketu do commita z Claude Code: kryteria akceptacji, tryb planowania, najpierw testy, małe, sprawdzane kroki i przegląd w świeżym kontekście.
- [Naprawianie błędów w Claude Code: cofanie, reset i wychodzenie z impasu](https://developertoolkit.ai/pl/claude-code/quick-start/error-recovery/): Wyjdź z zepsutych edycji, pętli poprawek, kaskadowych awarii testów i przepełnionego kontekstu dzięki /rewind, sesjom i bramkom weryfikacji w Claude Code.
- [Integracja Claude Code z IDE: VS Code, JetBrains i dowolny edytor](https://developertoolkit.ai/pl/claude-code/quick-start/ide-integration/): Zainstaluj rozszerzenie Claude Code dla VS Code lub wtyczkę JetBrains, wybierz bezpieczny tryb uprawnień i sprawdzaj zmiany diagnostyką IDE.
- [Instalacja Claude Code na macOS, Linuksie i Windows](https://developertoolkit.ai/pl/claude-code/quick-start/installation/): Zainstaluj Claude Code natywnym instalatorem, Homebrew, WinGet, apt/dnf/apk lub npm, wybierz kanał wydań i sprawdź instalację poleceniem claude doctor.
- [Konfiguracja serwerów MCP w Claude Code](https://developertoolkit.ai/pl/claude-code/quick-start/mcp-setup/): Podłącz Claude Code do serwerów MCP przez claude mcp add i .mcp.json, wybierz zakres, trzymaj sekrety poza gitem i udowodnij, że każdy serwer działa.
- [Od PRD przez plan do zadań w Claude Code: sprawdzalna droga od wymagań do kodu](https://developertoolkit.ai/pl/claude-code/quick-start/prd-workflow/): Zamień PRD w kryteria akceptacji, plan z trybu planowania zapisany w repozytorium i śledzoną listę zadań w Claude Code, z bramką testów na każde zadanie.
- [Inicjalizacja projektu dla Claude Code: CLAUDE.md, reguły i pamięć](https://developertoolkit.ai/pl/claude-code/quick-start/project-initialization/): Przygotuj repo pod Claude Code: uruchom /init, zostaw w CLAUDE.md tylko to, czego Claude nie wywnioskuje, zawęź reguły do ścieżek i sprawdź to przez /context.
- [Kontrola wersji z Claude Code: commity, konflikty, PR-y i worktree](https://developertoolkit.ai/pl/claude-code/quick-start/version-control/): Claude Code dzieli commity, rozwiązuje konflikty, otwiera PR-y i pracuje równolegle w worktree, a testy i review dowodzą każdej zmiany przed merge.
- [Claude Code - wersje, kanały wydań i aktualizacje](https://developertoolkit.ai/pl/claude-code/reference/): Sprawdź wersję i kanał wydań Claude Code, znajdź stronę o changelogu, aktualizacjach i podglądach oraz udowodnij, że aktualizacja niczego nie zepsuła.
- [Funkcje beta i podglądy badawcze w Claude Code](https://developertoolkit.ai/pl/claude-code/reference/beta-features/): Które funkcje Claude Code są w podglądzie badawczym, becie lub eksperymentalne, jak je włączać i wyłączać, bezpiecznie testować i zgłaszać błędy.
- [Historia wersji Claude Code](https://developertoolkit.ai/pl/claude-code/reference/changelog/): Wydania Claude Code od 1.0.0 do 2.1.296 z datami, zmianami, które psują skrypty i ustawienia, oraz bezpieczną procedurą aktualizacji dla CI i zespołów.
- [Procedury aktualizacji Claude Code](https://developertoolkit.ai/pl/claude-code/reference/upgrade-procedures/): Bezpieczna aktualizacja Claude Code - kanał wydań, kopia konfiguracji, aktualizacja według typu instalacji, skryptowy smoke test i cofnięcie wersji.
- [Przegląd i wdrożenie z Claude Code](https://developertoolkit.ai/pl/claude-code/ship/): Zmiana z Claude Code od diffa do produkcji: /code-review, bramka headless przed pushem, przegląd PR-a, akceptacja właściciela i przećwiczony rollback.
- [Claude Code w CI/CD z GitHub Actions i trybem headless](https://developertoolkit.ai/pl/claude-code/ship/ci-cd-integration/): Claude Code w GitHub Actions i zadaniach headless: prośby @claude, code review PR-ów, zgłoszenie w PR i naprawa CI z bramkami i limitem kosztów.
- [Konfiguracja pipeline'u z Claude Code](https://developertoolkit.ai/pl/claude-code/ship/ci-cd/): Generuj, przyspieszaj i zabezpieczaj pipeline'y GitHub Actions i GitLab CI z Claude Code, a każdą zmianę potwierdzaj actionlint, zizmor i pomiarem czasu.
- [Docker i Kubernetes z Claude Code](https://developertoolkit.ai/pl/claude-code/ship/containerization/): Generuj Dockerfile, stacki Compose, manifesty Kubernetes i charty Helm w Claude Code, a potem udowodnij ich poprawność hadolintem, Trivy, kubeconform i kind.
- [Automatyzacja wdrożeń z Claude Code](https://developertoolkit.ai/pl/claude-code/ship/deployment/): Claude Code pisze bramki przed wdrożeniem, przeglądy migracji, skrypty deploy i rollback oraz release notes; ty sprawdzasz je na stagingu zamiast czytać kod.
- [Automatyczne przeglądy kodu z Claude Code](https://developertoolkit.ai/pl/claude-code/ship/review-automation/): Niech Claude Code przejrzy każdy diff przed człowiekiem: /code-review, zarządzany Code Review z bramką scalania, REVIEW.md i warstwy zespołu Anthropic.
- [Claude Code w zespole i firmie](https://developertoolkit.ai/pl/claude-code/team/): Wdróż Claude Code w zespole po kolei: sieć, dostawca modelu, wspólna konfiguracja, ustawienia zarządzane, kontenery i Claude Tag, z dowodem, że działa.
- [Claude Tag: wspólna tożsamość Claude Code w Slacku](https://developertoolkit.ai/pl/claude-code/team/claude-tag/): Wdróż Claude Tag, by każdy mógł oznaczyć @Claude w Slacku do pracy w Claude Code: pakiety dostępu, repozytoria, ślady audytu i kontrola PR.
- [Konfiguracja kontenera deweloperskiego dla Claude Code](https://developertoolkit.ai/pl/claude-code/team/devcontainer-setup/): Jeden powtarzalny dev container z Claude Code dla całego zespołu: oficjalny feature, trwałe logowanie, przypięta polityka, firewall i test dymny w CI.
- [Integracja korporacyjna i bezpieczeństwo](https://developertoolkit.ai/pl/claude-code/team/enterprise-integration/): Wdrożenie Claude Code w całej firmie przez ustawienia zarządzane: dostarczanie, bazowa polityka, sandbox, telemetria i dowód, że polityka działa.
- [Konfiguracja bramki LLM dla Claude Code](https://developertoolkit.ai/pl/claude-code/team/llm-gateway/): Kieruj ruch Claude Code przez Amazon Bedrock, Google Cloud, Microsoft Foundry, Claude Platform on AWS lub bramkę LLM i udowodnij, że każda sesja nią idzie.
- [Konfiguracja proxy i VPN](https://developertoolkit.ai/pl/claude-code/team/proxy-configuration/): Claude Code za firmowym proxy, inspekcją TLS, mTLS lub VPN: zmienne, lista dozwolonych hostów, wdrożenie w zespole i weryfikacja konfiguracji.
- [Współpraca zespołowa ze wspólną konfiguracją Claude Code](https://developertoolkit.ai/pl/claude-code/team/team-collaboration/): Commituj CLAUDE.md, .claude/settings.json, .mcp.json i skille zespołu, by każdy klon miał ten sam setup Claude Code, i udowodnij to testem w CI.
- [Testowanie i debugowanie z Claude Code](https://developertoolkit.ai/pl/claude-code/test/): Udowodnij, że zmiana z Claude Code działa, i ustal, czemu nie działa: zablokowane testy, hooki, diagnoza tylko do odczytu i dowody zamiast czytania diffu.
- [Debugowanie z Claude Code w terminalu](https://developertoolkit.ai/pl/claude-code/test/debugging/): Przekazuj błędy potokiem do Claude Code, badaj kod bez edycji, dowodź przyczyny testem, znajduj regresje przez git bisect i analizuj awarie CI headless.
- [Generowanie testów i TDD z Claude Code](https://developertoolkit.ai/pl/claude-code/test/testing/): Generuj testy zgodne z wzorcami projektu, prowadź red-green-refactor z zablokowanym plikiem testów i udowadniaj siłę zestawu hookami, mutacjami i CI.

## Codex

- [Codex](https://developertoolkit.ai/pl/codex/): OpenAI Codex dla programistów i tech leadów: pierwsza zweryfikowana zmiana, wybór sandboxa i polityki akceptacji, dowód jakości i mapa przewodnika.
- [Automatyzacja Codexa: wybierz powierzchnię, potem udowodnij wynik](https://developertoolkit.ai/pl/codex/automate/): Codex bez nadzoru: codex exec, zaplanowane automatyzacje, zadania w chmurze, worktree, SDK, Slack i Linear oraz weryfikacja przebiegów bez czytania diffów.
- [Zaawansowana konfiguracja Codex: dostawcy, sandbox i ślad audytowy](https://developertoolkit.ai/pl/codex/automate/advanced-techniques/): Kieruj Codex przez bramę lub model lokalny, dobieraj rozumowanie do zadania, testuj sandbox i udowadniaj, co zrobił przebieg bez nadzoru (JSONL, OpenTelemetry).
- [Zaplanowane automatyzacje Codex, którym możesz zaufać bez nadzoru](https://developertoolkit.ai/pl/codex/automate/automations/): Cykliczne zadania Codex w aplikacji desktopowej lub w harmonogramie CI: przetestowane prompty, wąski sandbox, weryfikowalny wynik i naprawa awarii.
- [Środowiska chmurowe Codex: setup, cache, sieć i best-of-N](https://developertoolkit.ai/pl/codex/automate/cloud-environments/): Skonfiguruj środowiska chmurowe Codex: skrypty setup i maintenance, sekrety, cache kontenera, dostęp agenta do internetu, best-of-N i bramki w CLI.
- [Codex SDK w praktyce: wątki, ustrukturyzowany wynik i weryfikacja](https://developertoolkit.ai/pl/codex/automate/codex-sdk/): Steruj Codexem z TypeScriptu przez @openai/codex-sdk: wątki, sandbox, ustrukturyzowany wynik, streaming, wznawianie i bramka sprawdzająca każdy wynik.
- [Przepływy wieloagentowe w Codex: równoległe tory, subagenci i zadania w chmurze](https://developertoolkit.ai/pl/codex/automate/multi-agent-workflows/): Uruchom kilku agentów Codex naraz: podziel funkcje na tory, odpal sesje w worktree lub skrypt z codex exec, a potem bezpiecznie sprawdź i scal każdy tor.
- [Codex bez interakcji: codex exec](https://developertoolkit.ai/pl/codex/automate/non-interactive/): Codex w skryptach i CI przez codex exec: wybór sandboxa, JSON zgodny ze schematem, zdarzenia JSONL, wznawianie sesji, klucz API i bramki weryfikujące wynik.
- [Codex w Slacku i Linearze: delegowanie issue do zadań w chmurze](https://developertoolkit.ai/pl/codex/automate/slack-linear-integration/): Zamień wzmianki @ChatGPT w Slacku i delegowane issue z Lineara w zadania Codex w chmurze i sprawdzaj powstałe pull requesty bez czytania każdej linii.
- [Izolowane zadania Codex w Git worktrees](https://developertoolkit.ai/pl/codex/automate/worktrees/): Uruchamiaj każde zadanie Codex we własnym Git worktree (--worktree, /worktree, git worktree add), przygotuj je, sprawdź bramkami i posprzątaj bez utraty pracy.
- [Budowanie z Codexem: kontekst, izolacja i bramki](https://developertoolkit.ai/pl/codex/build/): Buduj funkcje z Codexem: załaduj właściwy kontekst, planuj w trybie read-only, implementuj w worktree, a o końcu pracy niech decydują testy i codex review.
- [Optymalizacja AGENTS.md i skilli w Codex](https://developertoolkit.ai/pl/codex/build/agents-md-optimization/): Zmieść łańcuch AGENTS.md w budżecie 32 KiB, przenieś procedury do skilli i sprawdź, co Codex załadował, poleceniem codex debug prompt-input.
- [API z Codex: najpierw kontrakt, weryfikacja po stronie maszyn](https://developertoolkit.ai/pl/codex/build/api-development/): Budujesz API REST z Codex: kontrakt OpenAPI, który sam przeglądasz, jeden worktree na wycinek endpointów oraz bramki lint, testów, fuzzingu i review.
- [Aplikacja desktopowa Codex: równoległe wątki, worktrees i review](https://developertoolkit.ai/pl/codex/build/app-mastery/): Uruchamiaj równoległe wątki aplikacji desktopowej Codex lokalnie, w worktree lub w chmurze, sprawdzaj je bramkami i codex review, a pracę przenoś przez Git.
- [Operacje masowe w Codex: jedna zmiana w wielu pakietach](https://developertoolkit.ai/pl/codex/build/batch-operations/): Wprowadź jedną zmianę w dziesiątkach pakietów lub repozytoriów z Codex: codemod, pilot, codex exec w worktree i bramka dla każdej partycji.
- [Komendy CLI Codex, komendy slash i skróty](https://developertoolkit.ai/pl/codex/build/cli-commands/): Codex CLI na co dzień: wznawianie, forki i nazwy sesji, komendy slash, skróty TUI, obrazy i bramka przeglądu. Sprawdzone na CLI 0.157.1.
- [Modernizacja legacy na dużą skalę z Codexem](https://developertoolkit.ai/pl/codex/build/codebase-modernization/): Modernizuj legacy z Codexem: utrwal zachowanie testami, migruj w równoległych worktree, trudne moduły wyślij do chmury z best-of-N i udowodnij każdą falę.
- [Zarządzanie kontekstem w różnych interfejsach Codex](https://developertoolkit.ai/pl/codex/build/context-patterns/): Długie sesje Codex w ryzach: mierz kontekst przez /status, steruj kompakcją, łącz wątki plikiem przekazania i przenoś pracę między CLI, IDE i chmurą.
- [Praca z bazą danych w Codex: schematy, migracje i zapytania, których działanie udowodnisz](https://developertoolkit.ai/pl/codex/build/database-work/): Projektuj schematy, generuj bezpieczne migracje Drizzle i optymalizuj zapytania PostgreSQL z Codexem. Każdą zmianę sprawdzaj na bazie z danymi testowymi.
- [Generowanie i utrzymanie dokumentacji z Codex](https://developertoolkit.ai/pl/codex/build/documentation/): Referencja API, dokumenty architektury i changelogi generowane przez Codex w worktree oraz wykrywanie rozjazdów przez codex exec, schemat JSON i bramki CI.
- [Szybsza praca z Codexem: skonfiguruj raz, oszczędzaj w każdej sesji](https://developertoolkit.ai/pl/codex/build/efficiency-hacks/): Skonfiguruj Codexa raz na co dzień: aliasy powłoki, powiadomienia i pasek statusu w config.toml, profile wysiłku i szybka bramka weryfikacji.
- [Promptowanie Codex: brief zadania, Plan mode i AGENTS.md](https://developertoolkit.ai/pl/codex/build/prompt-engineering/): Pisz dla Codex briefy zakończone sprawdzalnymi komendami, trwałe reguły trzymaj w AGENTS.md, planuj przed edycją i weryfikuj wynik bez czytania każdej linii.
- [Refaktoryzacja na dużą skalę z worktree w Codex](https://developertoolkit.ai/pl/codex/build/refactoring/): Refaktoryzuj setki plików z Codex: spisany plan, faza expand, worktree na partię, zapadka na starym API i bramki dowodzące, że zachowanie się nie zmieniło.
- [Eksploatacja Codex na produkcji](https://developertoolkit.ai/pl/codex/operate/): Codex na co dzień: zużycie w /status i /usage, eksport OpenTelemetry, kontrola instalacji przez codex doctor i audyt tego, co Codex wdraża.
- [Codex Security i centrum dowodzenia agentami](https://developertoolkit.ai/pl/codex/operate/codex-security/): Znaleziska Codex Security i @codex security review w jednym sprawdzonym procesie review, z sesjami Codex o minimalnych uprawnieniach i centrum agentów.
- [Kredyty, limity użycia i optymalizacja kosztów Codeksa](https://developertoolkit.ai/pl/codex/operate/cost-management/): Jak sprawić, by limity i kredyty Codeksa wystarczyły: /status i /usage, model i poziom rozumowania, krótszy kontekst i limity przebiegów bez nadzoru.
- [Optymalizacja wydajności z Codex](https://developertoolkit.ai/pl/codex/operate/performance/): Znajdź wąskie gardło wolnego endpointu z Codex, najpierw zacommituj benchmark, testuj konkurencyjne poprawki jako zadania best-of-N i przyjmuj tylko zmierzone.
- [Audyt bezpieczeństwa z Codex](https://developertoolkit.ai/pl/codex/operate/security-audit/): Audyt kodu z Codex CLI: najpierw skanery, potem równoległe audyty tylko do odczytu każdej domeny, test exploita przed poprawką w worktree i reguły w AGENTS.md.
- [Planowanie z Codex: kompletny plan przed pierwszą edycją](https://developertoolkit.ai/pl/codex/plan/): Przewodniki planowania w Codex dla programistów i tech leadów: zmapuj bazę kodu, zaprojektuj system i zacznij projekt od sprawdzalnego planu.
- [Projektowanie systemów z Codeksem](https://developertoolkit.ai/pl/codex/plan/architecture/): Zaprojektuj wydzielenie serwisu z Codeksem: zmapuj kod tylko do odczytu, sprawdź ryzyka spike'ami w chmurze, porównaj warianty w worktree, egzekwuj w CI.
- [Poznawanie nieznanej bazy kodu z Codex](https://developertoolkit.ai/pl/codex/plan/codebase-analysis/): Zmapuj nieznane repozytorium z Codex w sandboksie tylko do odczytu, z subagentami i zadaniami w chmurze, a potem udowodnij mapę cytowaniami i testem.
- [Nowy projekt z Codex](https://developertoolkit.ai/pl/codex/plan/new-project/): Postaw nowy serwis z Codex: najpierw specyfikacja, potem sam szkielet narzędzi, dowód, że bramki potrafią zawieść, AGENTS.md i pierwsza funkcja z worktree.
- [Codex – szybki start: od instalacji do sprawdzonego pierwszego zadania](https://developertoolkit.ai/pl/codex/quick-start/): Szybki start z Codex dla programistów: wybór środowiska pracy, instalacja, logowanie, konfiguracja i pierwsze zadanie sprawdzone testami i code review.
- [Konfiguracja AGENTS.md w Codeksie](https://developertoolkit.ai/pl/codex/quick-start/agents-md/): Napisz globalny i projektowy AGENTS.md dla Codexa, sprawdź przez codex debug prompt-input, co się wczytało, i udowodnij, że reguły zmieniają zachowanie.
- [Uwierzytelnianie](https://developertoolkit.ai/pl/codex/quick-start/authentication/): Wybierz logowanie ChatGPT lub klucz API w Codex, przechowuj poświadczenia, zaloguj się przez SSH i w CI, a wynik sprawdź poleceniami login status i doctor.
- [Konfiguracja Codex w config.toml: model, uprawnienia i profile](https://developertoolkit.ai/pl/codex/quick-start/configuration/): Świadomie ustaw config.toml w Codex: kolejność warstw, model i effort, profile uprawnień, filtrowanie sekretów, profile i dowód, że każde ustawienie działa.
- [Jak wyjść z błędów i złych decyzji Codex](https://developertoolkit.ai/pl/codex/quick-start/error-recovery/): Rozpoznaj typ awarii Codex, zastosuj właściwą poprawkę i cofnij zmiany Gitem: sandbox, nieudane polecenia, zły kierunek, długie wątki, MCP i logowanie.
- [Wykonaj swoje pierwsze zadanie w Codex](https://developertoolkit.ai/pl/codex/quick-start/first-task/): Pierwsze prawdziwe zadanie w Codex od początku do końca: zadanie do udowodnienia testem, prompt z kryteriami, CLI lub chmura i weryfikacja diffa.
- [Połącz Codex z GitHubem](https://developertoolkit.ai/pl/codex/quick-start/github-integration/): Połącz Codex z GitHubem: środowisko w chmurze, @codex review, reguły przeglądu w AGENTS.md, zadania z issues i merge blokowany przez CI.
- [Instalacja Codex: CLI, aplikacja desktopowa i rozszerzenie IDE](https://developertoolkit.ai/pl/codex/quick-start/installation/): Zainstaluj Codex CLI, aplikację desktopową i rozszerzenie IDE na macOS, Linuksie lub Windows, a potem sprawdź instalację: codex doctor i test tylko do odczytu.
- [Konfiguracja serwerów MCP w Codexie](https://developertoolkit.ai/pl/codex/quick-start/mcp-setup/): Podłącz Codexa do serwerów MCP przez codex mcp add i config.toml, ogranicz ich narzędzia i sekrety oraz sprawdź każdy serwer, zanim zaufasz jego wynikom.
- [Przegląd zmian Codex przed commitem](https://developertoolkit.ai/pl/codex/quick-start/review-workflow/): Sprawdź pracę Codex bez czytania każdej linii: uruchom bramki, /review lub codex review, oceń uwagi P0–P3, zostaw dobre hunki w Git i commituj.
- [Aktualna wersja Codex pod kontrolą](https://developertoolkit.ai/pl/codex/reference/): Sprawdź, którą wersję Codex uruchamiasz, aktualizuj CLI, rozszerzenie IDE i aplikację oraz przypinaj wersję w zespole, by nowe wydanie nie psuło CI.
- [Historia wersji Codex](https://developertoolkit.ai/pl/codex/reference/changelog/): Wydania Codex CLI od 0.95.0 do 0.162.1 z datami, nowościami i zmianami, które psują skrypty, oraz bezpieczna procedura aktualizacji dla CI i zespołu.
- [Przegląd i wdrożenie z Codex](https://developertoolkit.ai/pl/codex/ship/): Zmiana napisana przez Codex – od diffu do produkcji: warstwowy code review, bramki CI z codex-action, dowody przed scaleniem i wycofywalne wdrożenie.
- [Codex w CI/CD z GitHub Action](https://developertoolkit.ai/pl/codex/ship/ci-cd/): openai/codex-action w GitHub Actions: review PR, bramka bezpieczeństwa na ustrukturyzowanym wyniku, szkic release notes i auto-fix CI z ochroną sekretów.
- [Code review z Codex: jeden standard w CLI, aplikacji desktopowej i GitHubie](https://developertoolkit.ai/pl/codex/ship/code-review/): Review z Codex jako warstwowa bramka: codex exec review przed pushem, @codex review na PR-ach, reguły w AGENTS.md i test recenzenta na zasianych błędach.
- [Automatyzacja wdrożeń z Codex: kontenery, skrypty wdrożeniowe i rollback](https://developertoolkit.ai/pl/codex/ship/deployment/): Codex pisze i testuje Dockerfile, skrypty wdrożenia i rollbacku oraz migracje, a o produkcji decydują dowody z CI i chronione środowisko.
- [Automatyzacja pull requestów z Codex](https://developertoolkit.ai/pl/codex/ship/pr-automation/): Zmiana z Codex od worktree do merge: szkic PR z dowodami, codex review i @codex review, ograniczone poprawki CI oraz reguły merge, które decydują.
- [Jak przeglądać pracę Codex i nie zostać wąskim gardłem](https://developertoolkit.ai/pl/codex/ship/review-strategies/): Skaluj przegląd pracy Codex według klasy ryzyka: uprawnienia przed startem, raport z dowodami, właściwy przegląd i zatwierdzenie dla każdej klasy.
- [Codex w zespole i firmie](https://developertoolkit.ai/pl/codex/team/): Wdróż Codex w zespole w dobrej kolejności: logowanie, konfiguracja w repo, próg w requirements.toml, którego nikt nie obejdzie, i dowód, że działa.
- [Zarządzanie Codexem w firmie: requirements.toml, dostęp i audyt](https://developertoolkit.ai/pl/codex/team/enterprise-governance/): Zarządzaj Codexem w zespołach: dostęp w workspace, wymuszany requirements.toml, wdrożenie przez MDM, dowody audytowe i test CI potwierdzający politykę.
- [Współpraca zespołowa i wspólna konfiguracja w Codeksie](https://developertoolkit.ai/pl/codex/team/team-workflows/): Jedna konfiguracja Codeksa dla zespołu: AGENTS.md i .codex/config.toml w repo, przetestowane reguły i skille, onboarding w jednej sesji i bramka w CI.
- [Testowanie i debugowanie z Codex](https://developertoolkit.ai/pl/codex/test/): Udowodnij, że zmiana z Codex działa, i ustal, czemu nie działa: testy w AGENTS.md, diagnoza tylko do odczytu, najpierw czerwony test, dowody zamiast diffu.
- [Debugowanie i polowanie na błędy z Codexem](https://developertoolkit.ai/pl/codex/test/bug-hunting/): Debugowanie z Codexem od reprodukcji: CLI, worktree, chmura albo @codex zależnie od błędu, a poprawkę potwierdza test, który wcześniej nie przechodził.
- [Generowanie i uruchamianie testów z Codexem](https://developertoolkit.ai/pl/codex/test/testing/): Domknij luki w pokryciu z Codexem: osobny worktree na moduł, bramka „tylko testy”, przyrost pokrycia, testy mutacyjne i codex review przed merge'em.

## Workflows & method: Method

- [Metoda: najpierw specyfikacja i weryfikacja, potem delegowanie](https://developertoolkit.ai/pl/method/): Jak pracować z agentem: commituj łańcuch artefaktów, weryfikuj, zanim dasz mu więcej autonomii, i na bramkach czytaj dowody zamiast każdego diffa.
- [AI-native cykl życia oprogramowania](https://developertoolkit.ai/pl/method/lifecycle/): Planowanie, projektowanie, budowa, testy, wdrożenie i utrzymanie w jednej pętli: każdy etap commituje artefakt, a wskazana osoba zatwierdza bramkę.
- [Łańcuch artefaktów](https://developertoolkit.ai/pl/method/lifecycle/artifact-chain/): Zamień zgłoszenie w intent.md, spec.md, plan.md, diff z dowodami testów i wyniki review — każdy commitowany i akceptowany przed kolejnym etapem.
- [Build: plan.md, potem implementacja](https://developertoolkit.ai/pl/method/lifecycle/build/): Zamień zaakceptowany spec.md w plan.md zapisany w repozytorium w trybie tylko do odczytu, potem implementuj w worktree za hookami i samokontrolą.
- [Deploy: recenzuj w obie strony, bramkuj produkcję](https://developertoolkit.ai/pl/method/lifecycle/deploy/): Każdy pull request dostaje recenzję agenta, agent-autor zamyka własne wątki, a merge i produkcja stoją za bramkami, których agent nie przejdzie.
- [Design: napisz spec.md](https://developertoolkit.ai/pl/method/lifecycle/design/): Zamień zaakceptowany intent.md w commitowany spec.md w jednej sesji agenta, ze skillami polityk i każdym konfliktem oznaczonym przed budową.
- [Maintain: zamknij pętlę](https://developertoolkit.ai/pl/method/lifecycle/maintain/): Zamień alert produkcyjny w intent.md z dowodami bez ręcznego startu sesji: deterministyczna detekcja, diagnoza tylko do odczytu, ludzki triage.
- [Metryki AI-native SDLC](https://developertoolkit.ai/pl/method/lifecycle/metrics/): Jeden wskaźnik wyprzedzający i jeden opóźniony na każdy etap cyklu, liczone z gita, pull requestów, CI i incydentów. Widzisz, gdzie pętla zwalnia lub cieknie.
- [Plan: zapisz intent.md](https://developertoolkit.ai/pl/method/lifecycle/plan/): Zamień pomysł, ticket lub incydent w intent.md akceptowany przez product ownera przed designem: wywiad z agentem, szablon, kontrola w CI i wyjście z awarii.
- [Test: daj sesji pętlę informacji zwrotnej](https://developertoolkit.ai/pl/method/lifecycle/test/): Daj każdej sesji agenta testy jedną komendą, mierzalną definicję ukończenia, hook Stop, weryfikatora w świeżym kontekście i evale jego konfiguracji.
- [Mapa narzędzi: Claude Code, Cursor i Codex](https://developertoolkit.ai/pl/method/lifecycle/tool-map/): Każdy etap cyklu AI-native przypisany do funkcji Claude Code, Codex i Cursora, sprawdzonych w zainstalowanych CLI; artefakty i bramki zostają w Git.
- [Zasady pracy z agentami programistycznymi](https://developertoolkit.ai/pl/method/principles/): Zasady niezależne od narzędzia: tylko odczyt do akceptacji planu, najpierw testy, błędy jako specyfikacja, małe partie i decyzje człowieka na bramkach.
- [Kiedy używać trybu agenta, a kiedy trybu zapytań](https://developertoolkit.ai/pl/method/principles/agent-vs-ask-mode/): Plan mode tylko do odczytu, tryb zapisu czy praca bez nadzoru w Claude Code, Codeksie i Cursorze: co wybrać do zadania, jak przełączyć i jak sprawdzić wynik.
- [Ciągła dostawa z pomocą AI](https://developertoolkit.ai/pl/method/principles/continuous-delivery/): Małe zmiany od agenta, które da się udowodnić: commit na zadanie, limit rozmiaru PR-a w CI, bramki przed merge’em, flagi między deployem a wydaniem.
- [Programowanie sterowane błędami](https://developertoolkit.ai/pl/method/principles/error-driven-development/): Zamień błędy kompilatora, czerwone testy i stack trace'y w prompty dla agenta, prowadź ograniczoną pętlę poprawek i udowodnij jej wynik bez czytania diffu.
- [Człowiek w pętli: osąd przy bramkach, nie w każdym diffie](https://developertoolkit.ai/pl/method/principles/human-in-the-loop/): Gdzie potrzebny jest ludzki osąd, gdy kod piszą agenci: cztery bramki (intencja, spec, dowody, klasa ryzyka), a czytanie kodu tylko w klasach eskalacji.
- [Skuteczne techniki promptowania agentów AI](https://developertoolkit.ai/pl/method/principles/prompting-techniques/): Wzorce promptów, dzięki którym Claude Code, Codex i Cursor oddają sprawdzalną pracę: najpierw pytania, potem ograniczenia, przykład, plan i dowód.
- [Fabryki oprogramowania: jak zbudować taką, która nie zgnije](https://developertoolkit.ai/pl/method/principles/software-factories/): Czym jest fabryka oprogramowania, dlaczego kod agentów eroduje i jak przyznawać autonomię pętla po pętli: wyrocznia, limit WIP i metryki gnicia.
- [TDD z agentami AI: najpierw czerwony test](https://developertoolkit.ai/pl/method/principles/test-driven-development/): Najpierw czerwony test, potem implementacja agenta: czterofazowa pętla TDD, naprawa błędów od testu, zablokowane testy i dowód, że zielony wynik jest prawdziwy.

## Workflows & method: Workflows, all tools

- [Wspólne przepływy pracy: hub dla wszystkich narzędzi](https://developertoolkit.ai/pl/workflows/): Przepływy pracy wspólne dla Claude Code, Codex i Cursora według etapów: kontekst, harness, plan, budowa, testy, wdrożenie, eksploatacja, automatyzacja.
- [Automatyzacja](https://developertoolkit.ai/pl/workflows/automate/): Claude Code, Codex i Cursor bez nadzoru: cele, harmonogramy, agenci w chmurze, potok od zgłoszenia do PR i SDK, z bramkami, które dowodzą jakości.
- [Sterowanie agentami z kodu: Claude Agent SDK, Codex SDK i Cursor SDK](https://developertoolkit.ai/pl/workflows/automate/agent-sdks/): Kiedy sterować agentem z kodu zamiast go wyzwalać i czym różnią się Claude Agent SDK, Codex SDK i Cursor SDK – z jednym zadaniem triażu CI napisanym w każdym.
- [Agenci w tle i w chmurze: porównanie](https://developertoolkit.ai/pl/workflows/automate/background-agents/): Sesje w chmurze i rutyny Claude Code, Codex cloud, Cloud Agents Cursora, agent chmurowy Copilota i Jules: środowisko, wyzwalacze, limity i koszt.
- [Polecenie /goal: autonomiczne uruchomienia sterowane celem](https://developertoolkit.ai/pl/workflows/automate/goal-command/): Jak /goal utrzymuje Claude Code, Codex i Cursor w pracy, aż spełnią sprawdzalny warunek, kto w każdym z nich orzeka o końcu i jak udowodnić wynik.
- [Od intencji do produkcji: kompletny potok na przykładzie](https://developertoolkit.ai/pl/workflows/automate/intent-to-production/): Potok od zgłoszenia do PR przedłużony za merge: auto-merge według klasy ryzyka, progressive delivery, rollback po naruszeniu SLO i incydent jako ewaluacja.
- [Od zgłoszenia do pull requesta bez rąk na klawiaturze](https://developertoolkit.ai/pl/workflows/automate/issue-to-pr-pipeline/): Zgłoszenie z etykietą staje się gotowym do review PR w Claude Code, Codeksie lub Cursorze: izolowany przebieg, niezależne bramki, limit poprawek, dowody.
- [Polecenie /loop: prompty cykliczne i tryb adaptacyjny](https://developertoolkit.ai/pl/workflows/automate/loop-command/): Uruchamiaj prompt cyklicznie lub w tempie agenta z /loop w Claude Code i Cursorze, wymagaj dowodu z każdej rundy i sprawdź zamiennik w Codeksie.
- [Wzorce orkiestracji wielu agentów: planista, wykonawcy, sędzia](https://developertoolkit.ai/pl/workflows/automate/orchestration-patterns/): Fan-out/fan-in, pipeline, best-of-N z sędzią oraz autor i recenzent: kiedy każdy wzorzec się opłaca, ile kosztuje i jak go uruchomić w każdym narzędziu.
- [Budowanie z agentami: przepływ pracy dla twojej bazy kodu](https://developertoolkit.ai/pl/workflows/build/): Budowanie z Claude Code, Codeksem i Cursorem: wybierz przewodnik dla kształtu kodu, potem planuj, tnij i bramkuj zmiany tak, by dowodziły ich testy.
- [Tworzenie API z AI: najpierw kontrakt, weryfikacja maszynowa](https://developertoolkit.ai/pl/workflows/build/api-development/): API REST, GraphQL i gRPC z Claude Code, Codeksem lub Cursorem: kontrakt, który przeglądasz, wycinki od agenta i bramki dowodzące zgodności kodu.
- [Projektowanie baz danych i zapytania](https://developertoolkit.ai/pl/workflows/build/database-development/): Podłącz Claude Code, Codex lub Cursor do bazy przez serwer MCP tylko do odczytu, projektuj schematy, optymalizuj zapytania i udowadniaj bezpieczeństwo migracji.
- [Strategie dla milionów linii kodu z agentami](https://developertoolkit.ai/pl/workflows/build/large-codebases/): Praca z agentami w bazach kodu liczących miliony linii: warstwowe pliki instrukcji, MCP do analizy kodu, raport zasięgu zmian i bramki jakości.
- [Modernizacja legacy z agentami: program, nie prompt](https://developertoolkit.ai/pl/workflows/build/legacy-modernization/): Migracja legacy z agentami jako program z bramkami: testy charakteryzacyjne, szwy i plastry, równoległe fale, porównanie w cieniu i dowody przełączenia.
- [Rozwój systemów rozproszonych z AI](https://developertoolkit.ai/pl/workflows/build/microservices/): Buduj mikrousługi z Claude Code, Codeksem i Cursorem od kontraktu, tak by sagi, kontekst śladu i zmiany schematów potwierdzały testy, a nie lektura diffów.
- [Przepływy pracy w monorepozytoriach z asystentami AI](https://developertoolkit.ai/pl/workflows/build/monorepo-management/): Daj agentom AI graf monorepo, analizuj wpływ przed edycją, refaktoryzuj od dołu i udowodnij zmianę bramkami uruchamianymi tylko dla zmienionych pakietów.
- [Zarządzanie kontekstem w agentach programistycznych](https://developertoolkit.ai/pl/workflows/context/): Jak utrzymać Claude Code, Codex i Cursora na właściwym kontekście: która strona rozwiązuje który problem, komendy resetu i jak to sprawdzić.
- [Wyszukiwanie i indeksowanie kodu dla agentów AI: tekst, semantyka i symbole](https://developertoolkit.ai/pl/workflows/context/codebase-indexing/): Jak Claude Code, Codex i Cursor znajdują kod, które wyszukiwanie pasuje do pytania, jak odciąć szum i jak sprawdzić znaleziska agenta bez czytania plików.
- [Okna kontekstu i limity tokenów w agentach programistycznych](https://developertoolkit.ai/pl/workflows/context/context-windows/): Jak zapełnia się okno kontekstu agenta, jak je mierzyć w Claude Code, Codeksie i Cursorze oraz kiedy kompaktować, czyścić lub delegować pracę.
- [Optymalizacja kosztów kontekstu w agentach AI](https://developertoolkit.ai/pl/workflows/context/cost-per-context/): Jak obniżyć koszt agentów w Claude Code, Codeksie i Cursorze: zmierz zużycie tokenów, odchudź kontekst, dobierz model i udowodnij, że jakość nie spadła.
- [Dokumentacja jako efektywny kontekst AI](https://developertoolkit.ai/pl/workflows/context/documentation-as-context/): CLAUDE.md, AGENTS.md i reguły Cursora, których agent słucha: co w nich pisać, jak każde narzędzie je wczytuje i jak dowieść, że plik zgadza się z repo.
- [Struktura projektu zoptymalizowana pod agentów AI](https://developertoolkit.ai/pl/workflows/context/file-organization/): Jak ułożyć pliki, nazwy, testy i instrukcje katalogowe, żeby Claude Code, Codex i Cursor czytały tylko to, czego wymaga zadanie, i jak pilnować tego w CI.
- [Wzorce długookresowego zachowywania kontekstu](https://developertoolkit.ai/pl/workflows/context/memory-patterns/): Zdecyduj, co Claude Code, Codex i Cursor mają pamiętać między sesjami, umieść każdy fakt we właściwej warstwie i udowodnij, że pamięć się ładuje i działa.
- [Przycinanie CLAUDE.md i AGENTS.md: protokół ablacji](https://developertoolkit.ai/pl/workflows/context/pruning-context-files/): Tnij CLAUDE.md, AGENTS.md i reguły Cursora zamiast dopisywać linię po każdym błędzie: co ładuje każde narzędzie, gdzie trafia reguła i sześć promptów.
- [Harness: wszystko, w czym pracuje agent](https://developertoolkit.ai/pl/workflows/harness/): Siedem warstw wokół agenta: kontekst, narzędzia, uprawnienia, hooki, skille, pluginy i środowiska. Przed czym chroni każda i jak testować harness.
- [Jak przygotować repozytorium do pracy agentów](https://developertoolkit.ai/pl/workflows/harness/agent-ready-codebase/): Sześć cech repozytorium, dzięki którym kontrole zastępują czytanie diffów agenta: ocena 0–3 dla każdej, prompt audytowy i kolejność napraw.
- [Efemeryczne środowiska: pełny stos dla każdego zadania agenta](https://developertoolkit.ai/pl/workflows/harness/ephemeral-environments/): Każde zadanie agenta dostaje własny stos z danymi: blok portów, bazę, zaślepki usług i sprzątanie, lokalnie albo w chmurze Claude Code, Codex i Cursora.
- [Uprawnienia, sandboksy i tryby zatwierdzania w Claude Code, Codex i Cursorze](https://developertoolkit.ai/pl/workflows/harness/permissions-and-sandboxing/): Tryby zatwierdzania, sandboksy systemowe i ruch sieciowy w Claude Code, Codex i Cursorze oraz ustawienia na każdą klasę ryzyka i typ uruchomienia.
- [DevOps z AI](https://developertoolkit.ai/pl/workflows/operate/): Produkcja z Claude Code, Codeksem i Cursorem: dostęp tylko do odczytu przez MCP, poprawki szkicowane przez agenta i bramki, które dowodzą każdej zmiany.
- [Obserwowalność agentów: ślady, wywołania narzędzi, koszty i logi audytowe](https://developertoolkit.ai/pl/workflows/operate/agent-observability/): Eksportuj telemetrię agentów przez OpenTelemetry, łącz przebiegi z pull requestami i incydentami, zbuduj dashboard skuteczności i kosztu oraz ustal retencję.
- [Zarządzanie kosztami chmury i FinOps z agentami kodującymi](https://developertoolkit.ai/pl/workflows/operate/cloud-cost-optimization/): Wyjaśnij rachunek za chmurę, uszereguj marnotrawstwo i zamień right-sizing w zrecenzowany Terraform z Claude Code, Codex i Cursorem na MCP tylko do odczytu.
- [Jak utrzymać w zdrowiu kod pisany przez agentów](https://developertoolkit.ai/pl/workflows/operate/codebase-health/): Co tydzień mierz przeróbki, reverty, złożoność, duplikację i hotspoty, obniżaj autonomię pętli po przekroczeniu progów i planuj pętle refaktoryzacji.
- [Automatyzacja zgodności regulacyjnej](https://developertoolkit.ai/pl/workflows/operate/compliance-automation/): Claude Code, Codex lub Cursor mapują kontrole SOC 2, HIPAA i RODO (GDPR) na kod, budują bramki CI i zbierają dowody audytowe sprawdzalne bez czytania całości.
- [Odzyskiwanie po awarii z AI](https://developertoolkit.ai/pl/workflows/operate/disaster-recovery/): Przywróć działanie po złej zmianie agenta i po utracie infrastruktury – odwracalne commity, runbooki PITR, kontrola dryfu i próby chaosu mierzące RTO i RPO.
- [Taksonomia błędów w zmianach pisanych przez agentów](https://developertoolkit.ai/pl/workflows/operate/failure-taxonomy/): Siedem klas błędów w zmianach agentów, każda przypisana do najwcześniejszej kontroli, która ją łapie, ze schematem tagów, klasyfikatorem i raportem priorytetów.
- [Reagowanie na incydenty wspomagane przez AI](https://developertoolkit.ai/pl/workflows/operate/incident-response/): Incydenty z Claude Code, Codeksem lub Cursorem na MCP tylko do odczytu — oś czasu ze źródłami, zatwierdzona mitygacja, zmierzony powrót do normy i post-mortem.
- [Monitorowanie i obserwowalność](https://developertoolkit.ai/pl/workflows/operate/monitoring-observability/): Claude Code, Codex lub Cursor instrumentują serwis przez OpenTelemetry i generują alerty oraz dashboardy, a testy promtool i zapytania MCP to weryfikują.
- [Optymalizacja wydajności produkcyjnej](https://developertoolkit.ai/pl/workflows/operate/performance-tuning/): Diagnozuj regresje p99, wyczerpanie puli połączeń i oscylujący autoskaler z agentem na serwerach MCP Kubernetes, Postgresa i metryk tylko do odczytu.
- [Automatyzacja operacji bezpieczeństwa](https://developertoolkit.ai/pl/workflows/operate/security-operations/): Semgrep, npm audit, Trivy i Gitleaks jako bramki CI, triage wyników przez Claude Code, Codex lub Cursor według schematu i poprawki jako recenzowane PR-y.
- [Planowanie i specyfikacja: kontrakt przed kodem](https://developertoolkit.ai/pl/workflows/plan/): Planowanie z Claude Code, Codeksem i Cursorem: intencja, specyfikacja, wykonywalne kryteria akceptacji, ADR i kontrakt wizualny zatwierdzone przed kodem.
- [Wykonywalne kryteria akceptacji: od historyjki do czerwonego testu](https://developertoolkit.ai/pl/workflows/plan/acceptance-criteria/): Zamień każde kryterium akceptacji w scenariusz Given/When/Then i czerwony test, zanim agent zacznie kodować, zablokuj go i zatwierdzaj kontrakt zamiast diffu.
- [Przepływy pracy Agile: integracja Scruma i Kanbana](https://developertoolkit.ai/pl/workflows/plan/agile-workflows/): Scrum i Kanban z agentami: doprecyzuj historyjki, planuj sprint pod przepustowość review, ustaw limit WIP na review dowodów i buduj przegląd sprintu z PR-ów.
- [Decyzje architektoniczne, których agenci przestrzegają](https://developertoolkit.ai/pl/workflows/plan/architecture-decisions/): Krótkie ADR-y, których ograniczenia wskazują test w CI, wczytane do Claude Code, Codeksa i Cursora, żeby agenci po cichu nie rozmywali architektury.
- [Behavior-driven development z agentami AI](https://developertoolkit.ai/pl/workflows/plan/behavior-driven-dev/): Zatwierdzone scenariusze Gherkin jako kontrakt, pod który koduje agent AI: example mapping, zablokowane pliki .feature, kroki Cucumber.js i bramki CI.
- [Domain-driven design z agentami AI](https://developertoolkit.ai/pl/workflows/plan/domain-driven-design/): Daj Claude Code, Codeksowi i Cursorowi język wszechobecny, przypnij niezmienniki agregatu testami i pilnuj granic kontekstów regułą zależności w CI.
- [Pipeline design-to-code z czterema artefaktami](https://developertoolkit.ai/pl/workflows/plan/four-stage-pipeline/): Prowadź UI od intencji do zweryfikowanego kodu przez cztery artefakty z bramkami: kierunek wizualny, prototyp, kontrakt designu i implementację z dowodami.
- [Ocena i iteracja oparte na dowodach](https://developertoolkit.ai/pl/workflows/plan/rating-loop/): Oceń handoff designu lub specyfikacji recenzentem read-only, rubryką JSON i bramką w skrypcie, a potem iteruj do progu albo warunku stopu.
- [Spec-driven development: specyfikacja jako źródło prawdy](https://developertoolkit.ai/pl/workflows/plan/spec-driven-development/): Jak utrzymać spec.md jako źródło prawdy: delta specyfikacji w każdym PR-ze, testy CI wykrywające dryf oraz zwykły markdown kontra Spec Kit, OpenSpec, Kiro i BMAD.
- [Code review i wdrożenie](https://developertoolkit.ai/pl/workflows/ship/): Wdrażaj zmiany agentów na podstawie dowodów: pakiet w PR pilnowany przez CI, triaż agenta review, bramki pipeline’u, progressive delivery i rollback.
- [Code review PR-a agenta bez czytania każdej linii](https://developertoolkit.ai/pl/workflows/ship/agent-pr-review/): Sześć kroków oceny PR-a agenta: zmiana specyfikacji, dowody, flagi ryzyka, zmiany wyroczni, próbka hotspotów, a potem akceptacja, zwrot albo eskalacja.
- [Automatyzacja pipeline'ów z AI](https://developertoolkit.ai/pl/workflows/ship/ci-cd-pipelines/): Claude Code, Codex lub Cursor piszą CI świadome zmian i robią triage niestabilnych testów, a bramki dowodzą, że każda zmiana agenta nadal chroni main.
- [Konteneryzacja z Dockerem i Kubernetesem](https://developertoolkit.ai/pl/workflows/ship/containerization/): Claude Code, Codex lub Cursor piszą Dockerfile i manifesty Kubernetes, debugują pody OOMKilled, a skanery i dry run dowodzą jakości bez czytania.
- [Pakiet dowodów: co musi udowodnić pull request agenta](https://developertoolkit.ai/pl/workflows/ship/evidence-bundle/): Kontrakt pull requesta agenta: zmiana specyfikacji, wyniki akceptacji, sprawdzenia, dowody z działania, klasa ryzyka, pochodzenie i wymuszający go check CI.
- [Infrastruktura jako kod z agentami AI](https://developertoolkit.ai/pl/workflows/ship/infrastructure-code/): Claude Code, Codex lub Cursor piszą zmiany w Terraform, CloudFormation, CDK i Pulumi, a CI dowodzi ich poprawności bramkami, planem i kontrolą dryfu.
- [Progressive delivery dla zmian pisanych przez agentów](https://developertoolkit.ai/pl/workflows/ship/progressive-delivery/): Flagi funkcji, canary i automatyczny rollback wyzwalany przez SLO jako siatka pod zmianami agentów, których nie czytasz, z budżetem zasięgu na klasę ryzyka.
- [Testowanie i weryfikacja kodu pisanego przez agentów](https://developertoolkit.ai/pl/workflows/test/): Od czego zacząć weryfikację kodu agentów: strony o testach w kolejności, w jakiej ich potrzebujesz, od siły wyroczni po dowody dla recenzenta.
- [Testy dostępności z agentami AI: bramki WCAG 2.2 AA w CI](https://developertoolkit.ai/pl/workflows/test/accessibility-testing/): Zablokuj regresje WCAG 2.2 AA w UI pisanym przez agentów: baseline axe-core w Playwright, testy klawiatury, MCP przeglądarki i test z czytnikiem ekranu.
- [Automatyzacja testów API](https://developertoolkit.ai/pl/workflows/test/api-testing/): Agent pisze testy REST i GraphQL z kontraktu, macierz autoryzacji i kontrakty Pact, a ty dowodzisz, że zestaw łapie błędy, bez czytania każdej linii.
- [Testy charakteryzacyjne: utrwal zachowanie legacy, zanim dotknie go agent](https://developertoolkit.ai/pl/workflows/test/characterization-tests/): Utrwal to, co kod legacy robi dziś: snapshoty, testy zatwierdzające i golden master na szwie, dowód, że mogą paść, i blokada przed refaktoryzacją agenta.
- [Bramy jakości dla kodu pisanego przez agentów](https://developertoolkit.ai/pl/workflows/test/code-quality/): Formatowanie, lint, typy i analiza statyczna w pętli agenta i jako wymagane joby CI, a code review przez AI jako rada, nie brama.
- [Zmyślone pakiety i slopsquatting: kontrola zależności w zmianach agentów](https://developertoolkit.ai/pl/workflows/test/dependency-verification/): Zatrzymaj zmyślone, podrobione, zbyt świeże i źle licencjonowane pakiety od agentów: bramka CI na diffie lockfile'a, cooldown, proxy rejestru i hook.
- [Automatyzacja testów end-to-end](https://developertoolkit.ai/pl/workflows/test/e2e-testing/): Agent pisze i utrzymuje zestaw testów E2E w Playwright na podstawie kryteriów akceptacji, a ty udowadniasz, że wyłapuje regresje, bez czytania każdego testu.
- [Testy wstrzykiwania awarii: udowodnij, że timeouty, ponowienia i circuit breakery działają](https://developertoolkit.ai/pl/workflows/test/error-injection-testing/): Spisz macierz awarii, zleć Claude Code, Codeksowi lub Cursorowi testy z Toxiproxy i Chaos Mesh i udowodnij, że timeouty, ponowienia i breakery działają.
- [Funkcje dopasowania architektury: utrzymywalność bez czytania kodu](https://developertoolkit.ai/pl/workflows/test/fitness-functions/): Warstwy, cykle, złożoność, duplikacja i publiczne API jako bramki CI z zapadką: kod pisany przez agentów zostaje utrzymywalny bez czytania każdej linii.
- [Wzorce testowania integracyjnego](https://developertoolkit.ai/pl/workflows/test/integration-testing/): Agent pisze testy integracyjne na prawdziwej bazie, kolejce i stubach API, a ty bez czytania kodu sprawdzasz, że każdy test potrafi wykryć błąd.
- [Testowanie aplikacji mobilnych z agentami AI](https://developertoolkit.ai/pl/workflows/test/mobile-testing/): Agent pisze i uruchamia testy Detox, Maestro i Flutter na symulatorze, dobiera macierz urządzeń i dowodzi, że testy łapią błędy, zanim im zaufasz.
- [Kontrole oceniane przez model: sędziowie z rubryką tam, gdzie nie sięgają testy](https://developertoolkit.ai/pl/workflows/test/model-graded-checks/): Oceniaj teksty UX, dokumentację, zrzuty ekranu i uwagi z code review sędzią z rubryką: zbiór kalibracyjny, zgodność, kontrole wyrywkowe, zero samooceny.
- [Jak silna jest twoja wyrocznia? Zaufanie do testów, których nie czytałeś](https://developertoolkit.ai/pl/workflows/test/oracle-strength/): Jak zmierzyć, czy testy łapią błędy: wynik mutacyjny, pokrycie zachowań, pochodzenie testów i niestabilność oraz próg dla pętli bez nadzoru.
- [Testy obciążenia, stresu i benchmarków](https://developertoolkit.ai/pl/workflows/test/performance-testing/): Agent pisze testy obciążenia i stresu w k6 na podstawie twoich progów opóźnień, szereguje wąskie gardła według dowodów, a CI blokuje regresje p95.
- [Testy oparte na właściwościach dla kodu pisanego przez agentów](https://developertoolkit.ai/pl/workflows/test/property-based-testing/): Zamień wymagania ze spec.md w niezmienniki sprawdzane przez fast-check, Hypothesis i proptest na generowanych danych, a zredukowane błędy przypnij jako testy.
- [Ochrona wyroczni: testy, których agent nie może zmienić](https://developertoolkit.ai/pl/workflows/test/protect-the-oracle/): Zablokuj testy regułami deny, profilem sandboxa i CODEOWNERS, uruchamiaj decydujący check poza diffem, trzymaj holdouty poza repo i wykrywaj osłabianie testów.
- [Testy bezpieczeństwa kodu pisanego przez agentów](https://developertoolkit.ai/pl/workflows/test/security-testing/): Udowodnij testami, nie opiniami, że kod agenta jest bezpieczny: macierz autoryzacji, testy nadużyć i test exploita dla każdego znaleziska recenzji AI.
- [Jak wyłapać kod wiarygodny, ale błędny, przed merge'em](https://developertoolkit.ai/pl/workflows/test/slop-detection/): Katalog pięciu wzorców slopu w kodzie agentów: dla każdego przetestowany detektor w lincie lub CI i prompt dla recenzenta na to, czego detektor nie widzi.
- [Strategie danych testowych i fixtures](https://developertoolkit.ai/pl/workflows/test/test-data-management/): Agent buduje deterministyczne fabryki, seedy scenariuszy i syntetyczne dane bez PII, a CI dowodzi ich poprawności testami kontraktowymi i bramką PII.
- [Strategie i generowanie testów jednostkowych z agentami AI](https://developertoolkit.ai/pl/workflows/test/unit-testing/): Testy jednostkowe od agenta, które łapią błędy: zatwierdzona lista zachowań, mocki tylko na granicach, kontrola negatywna dla każdego testu i testy mutacyjne.

## Ecosystem & comparisons: Choose a tool

- [Przegląd porównania narzędzi](https://developertoolkit.ai/pl/comparison/): Cursor, Claude Code i Codex wykonują tę samą pętlę agenta na trzech powierzchniach. Wybierz według miejsca pracy i sprawdź wybór bake-offem na jednym zadaniu.
- [Rynek agentów kodujących poza wielką trójką](https://developertoolkit.ai/pl/comparison/agent-landscape/): Agenci kodujący poza Claude Code, Codex i Cursorem: gdzie działa każdy z nich, co automatyzuje i jak porównać go w bake-offie na własnym repozytorium.
- [Cursor czy Claude Code: kiedy którego używać](https://developertoolkit.ai/pl/comparison/cursor-vs-claude-code/): Cursor czy Claude Code? Tabela decyzji według zadań, prompty dla obu narzędzi, jedna bramka weryfikacji i praca z oboma w jednym repozytorium.
- [Cursor vs Claude Code vs Codex: macierz porównania funkcji](https://developertoolkit.ai/pl/comparison/feature-matrix/): Claude Code, Codex i Cursor porównane wiersz po wierszu, z wersjami: powierzchnie, zabezpieczenia, review, tryb headless i prompty do sprawdzenia w repo.
- [Gemini CLI, Jules i Antigravity](https://developertoolkit.ai/pl/comparison/gemini-cli/): Trzej agenci kodujący Google: co automatyzują Gemini CLI, Jules i Antigravity, kto po czerwcu 2026 zachował darmowy dostęp i jak wpiąć je obok wielkiej trójki.
- [GitHub Copilot jako agent kodujący: cloud agent, aplikacja, CLI i rozliczenia](https://developertoolkit.ai/pl/comparison/github-copilot/): Cloud agent, aplikacja i CLI GitHub Copilot: skille, hooki, MCP, rozliczenia w AI Credits od 1 czerwca 2026, agenci Claude i Codex oraz polityki organizacji.
- [Kiro: pliki specyfikacji, testy właściwości i Kiro Crew](https://developertoolkit.ai/pl/comparison/kiro/): Specyfikacje Kiro, testy oparte na właściwościach i open source’owy Kiro Crew oraz plany Kiro (stan na 2026-10-12) i jak przenieść je do Claude Code, Codex i Cursora.
- [Przejście na Cursor, Claude Code lub Codex: przewodnik migracji](https://developertoolkit.ai/pl/comparison/migration-guide/): Przenieś zespół na Cursor, Claude Code lub Codex: wybór narzędzia, import konfiguracji, test na własnym repo, etapowe wdrożenie, pomiar i plan wycofania.
- [OpenCode: agent open source dla dowolnego modelu](https://developertoolkit.ai/pl/comparison/opencode/): OpenCode 1.19.0 w npm (2026-10-12), działanie sprawdzone na 1.18.32: instalacja, routing modeli hostowanych i open-weight oraz porównanie z Claude Code, Codex i Cursorem.
- [Ceny planów narzędzi AI do kodowania i rozliczanie zużycia](https://developertoolkit.ai/pl/comparison/pricing-analysis/): Ile kosztują plany z agentem kodującym (stan na 2026-10-12), jak rozliczane jest zużycie ponad miejsce i jak wycenić zespół z faktur.
- [Od zwykłego czatu do zintegrowanego developmentu](https://developertoolkit.ai/pl/comparison/vs-chatgpt/): Kiedy wystarczy zwykły czat ChatGPT, a kiedy przenieść pracę do Codex, Claude Code lub Cursora i jak sprawdzić diff agenta bez czytania każdej linii.
- [Codex vs Cursor i Claude Code: mocne strony i kompromisy](https://developertoolkit.ai/pl/comparison/vs-codex/): Gdzie Codex, dostępny w CLI, IDE, chmurze i Slacku, wygrywa z Cursorem i Claude Code, ile to kosztuje i jaka bramka obowiązuje wszystkie trzy.
- [Claude Code, Codex i Cursor kontra GitHub Copilot](https://developertoolkit.ai/pl/comparison/vs-github-copilot/): GitHub Copilot to w 2026 pełna platforma agentowa. Porównaj ją z Claude Code, Codex i Cursorem: harness, limity, modele, rozliczenia i uczciwy bake-off.
- [Cursor, Claude Code i Codex vs Devin Desktop (dawniej Windsurf)](https://developertoolkit.ai/pl/comparison/vs-windsurf/): Devin Desktop, dawniej Windsurf, obok Cursora, Claude Code i Codexa: co dało się zweryfikować 2026-09-26 i 2026-10-12, tabela decyzji i próba na jednym zadaniu.

## Ecosystem & comparisons: Models, MCP, skills and agent tools

- [Skille, serwery MCP czy pluginy: co wybrać i gdzie tego szukać](https://developertoolkit.ai/pl/ecosystem/): Wybierz między AGENTS.md, skillem, komendą slash, subagentem, hookiem, serwerem MCP i pluginem, a potem znajdź półkę ekosystemu, która je opisuje.
- [Narzędzia agentowe: multipleksery, środowiska desktopowe, sandboksy, gatewaye i więcej](https://developertoolkit.ai/pl/ecosystem/agent-tools/): Narzędzia firm trzecich wokół Claude Code, Codeksa i Cursora: sześć półek, wbudowane funkcje na start, pułapki licencyjne i checklista przed wdrożeniem.
- [Desktopowe środowiska agentów: Orca, Conductor, Superset, Emdash, Warp i inne](https://developertoolkit.ai/pl/ecosystem/agent-tools/agent-shells/): Porównanie aplikacji, które uruchamiają Claude Code, Codex i CLI Cursora równolegle w worktree: Orca, Conductor, Superset, Emdash, Warp. Licencje i pułapki.
- [Bramki i modele lokalne: LiteLLM, CC Switch, Claude Code Router, Ollama i LM Studio](https://developertoolkit.ai/pl/ecosystem/agent-tools/gateways-local-models/): Claude Code i Codex przez LiteLLM, CC Switch, Claude Code Router lub OpenRouter albo na Ollamie, LM Studio i llama.cpp, z budżetem na osobę.
- [Agenci bez interfejsu w CI: claude -p, codex exec i Agent SDK](https://developertoolkit.ai/pl/ecosystem/agent-tools/headless-agents-ci/): Claude Code i Codex bez nadzoru w CI: flagi claude -p i codex exec, werdykty zgodne ze schematem, Agent SDK i kontrola PR, która w razie wątpliwości blokuje.
- [herdr: multiplekser agentów ze skryptowalnym API](https://developertoolkit.ai/pl/ecosystem/agent-tools/herdr-agent-multiplexer/): Zainstaluj herdr 0.9.1, zobacz, jak naprawdę wykrywa zablokowanych agentów, i każ jednemu agentowi prowadzić trzech wykonawców i recenzenta.
- [Poza wielką trójką: OpenCode, Pi, Copilot CLI, Cline, Goose i inni agenci kodujący](https://developertoolkit.ai/pl/ecosystem/agent-tools/other-coding-agents/): Instalacja, status i licencje dziesięciu popularnych agentów kodujących spoza Claude Code, Codeksa i Cursora oraz zespół agentów na jednym pliku reguł.
- [Dziesięciu agentów naraz: herdr, Conductor i worktree](https://developertoolkit.ai/pl/ecosystem/agent-tools/parallel-agents/): Wielu agentów naraz: worktree na zgłoszenie, własne porty, herdr lub Conductor do nadzoru oraz kolejka review i merge train, które bezpiecznie scalają pracę.
- [Sterowanie agentami z telefonu: Remote Control, Happy, CloudCLI i Orca Mobile](https://developertoolkit.ai/pl/ecosystem/agent-tools/remote-mobile/): Nadzoruj Claude Code i Codex z telefonu przez Remote Control, codex remote-control, Happy, CloudCLI lub Orca: konfiguracja, zgody, bezpieczeństwo i limity.
- [Sandboksy dla agentów: container-use, E2B, Daytona, microVM i Docker](https://developertoolkit.ai/pl/ecosystem/agent-tools/sandboxes/): Wybierz sandboks dla agentów: izolacja, start, czas życia i ceny container-use, E2B, Docker Sandboxes, Modal, Daytona i Codera.
- [tmux dla flot agentów: sesje, send-keys, wait-for](https://developertoolkit.ai/pl/ecosystem/agent-tools/tmux-for-agent-fleets/): Claude Code, Codex i Cursor same tworzą worktree. Co we flocie agentów nadal należy do tmuxa: trwałość, widoczność, wiadomości i bariery.
- [Sterowanie głosem w pracy z agentami](https://developertoolkit.ai/pl/ecosystem/agent-tools/voice-input/): Dyktuj prompty do Claude Code (/voice), Codeksa, Copilot CLI i Cursora: tryb tap, odpowiedzi w sesji grill-me i sprawdzenie, co agent naprawdę usłyszał.
- [Frameworki pracy z agentami: porównanie](https://developertoolkit.ai/pl/ecosystem/frameworks/): Superpowers, Spec Kit, OpenSpec, BMAD, GSD, Compound Engineering i inne: rodziny, artefakty i koszt kontekstu oraz pilotaż na jednej funkcji.
- [Godziny autonomii: GSD Core, pętle Ralph, /goal i oh-my-claudecode](https://developertoolkit.ai/pl/ecosystem/frameworks/autonomous-loops/): Wybierz i uruchom pętlę agenta bez nadzoru: /goal, wtyczka ralph-loop, Ralph od snarktank i frankbria, GSD Core, oh-my-claudecode i oh-my-codex w sandboksie.
- [BMAD Method: role zwinne jako agenci](https://developertoolkit.ai/pl/ecosystem/frameworks/bmad-method/): Jedna funkcja przez agentów PM, architekta i dewelopera z BMAD w Claude Code, Codex i Cursorze oraz kiedy dobór ceremonii w bmad-build uzasadnia role.
- [Compound Engineering: pętla, wtyczka i dowody](https://developertoolkit.ai/pl/ecosystem/frameworks/compound-engineering/): Zainstaluj wtyczkę Compound Engineering (3.29.0) w Claude Code, Codex lub Cursorze, uruchom jej pętlę, zweryfikuj wynik i odnieś ją do drabiny autonomii.
- [Pakiety dyscypliny: skille Pococka, gstack, agent-skills, Ponytail i ECC](https://developertoolkit.ai/pl/ecosystem/frameworks/discipline-packs/): Porównanie pięciu pakietów dyscypliny dla agentów i połączenie jednego pakietu „co budować” z hamulcem Ponytail „ile kodu”, sprawdzane testami.
- [Frameworki z audytem i standardami: AI-DLC, Agent OS, Tessl i specyfikacje w stylu Kiro](https://developertoolkit.ai/pl/ecosystem/frameworks/enterprise-frameworks/): AWS AI-DLC z bramkami akceptacji i commitowanym śladem audytowym oraz wybór między Agent OS, Tessl, cc-sdd i Conductorem dla standardów i specyfikacji.
- [Everything Claude Code: największy pakiet w praktyce](https://developertoolkit.ai/pl/ecosystem/frameworks/everything-claude-code/): Co instaluje Everything Claude Code (ECC), jedna funkcja zbudowana z nim od A do Z, co zostawić, co wyciąć i koszt ~41,5 tys. tokenów kontekstu.
- [GSD: fazy z inżynierią kontekstu dla samodzielnych twórców](https://developertoolkit.ai/pl/ecosystem/frameworks/gsd/): Pętla discuss, plan, execute, verify i ship z GSD Core na jednym projekcie w Claude Code, Codex lub Cursorze: co automatyzuje i ile kosztuje w tokenach.
- [gstack: stos skilli opartych na rolach dla Claude Code](https://developertoolkit.ai/pl/ecosystem/frameworks/gstack/): Przeprowadź jedną funkcję przez role gstack: produkt, engineering manager, reviewer, QA i release, i przypisz ich wyniki do łańcucha artefaktów.
- [Harnessy wieloagentowe i katalogi: Ruflo, wshobson/agents, SuperClaude, Task Master i CCPM](https://developertoolkit.ai/pl/ecosystem/frameworks/multi-agent-harnesses/): Zamień PRD w graf zadań, issues na GitHubie i równoległych agentów z CCPM, Task Master i wshobson/agents oraz sprawdź, gdzie pasują Ruflo i SuperClaude.
- [OpenSpec: propozycje zmian i żywe specyfikacje](https://developertoolkit.ai/pl/ecosystem/frameworks/openspec/): Pętla propose, apply i archive w OpenSpec na istniejącym kodzie w Claude Code, Codex i Cursorze oraz reguła, kiedy wygrywa ze Spec Kit.
- [Jedno źródło reguł dla każdego agenta: AGENTS.md, Ruler i rulesync](https://developertoolkit.ai/pl/ecosystem/frameworks/rules-sync/): Jeden zestaw reguł dla Claude Code, Codeksa i Cursora: import AGENTS.md, Ruler, rulesync i zadanie CI, które wykrywa rozjazd plików.
- [Frameworki spec-driven: Spec Kit kontra OpenSpec kontra BMAD kontra Superpowers](https://developertoolkit.ai/pl/ecosystem/frameworks/spec-driven-frameworks/): Wybierz framework spec-driven dla agentów: Spec Kit, OpenSpec, BMAD, Superpowers i cc-sdd na jednej funkcji, z instalacją, bramkami review i kosztami.
- [GitHub Spec Kit: spec-driven development w praktyce](https://developertoolkit.ai/pl/ecosystem/frameworks/spec-kit/): GitHub Spec Kit od początku do końca w Claude Code, Codex i Cursorze: konstytucja, specify, plan, tasks, implement i converge, z generowanymi plikami.
- [Superpowers: zdyscyplinowany proces tworzenia oprogramowania z agentami](https://developertoolkit.ai/pl/ecosystem/frameworks/superpowers/): Superpowers 6.4.2 w Claude Code, Codex i Cursorze: brainstorming, plan, TDD z subagentami, review i zweryfikowane zakończenie oraz koszty i pułapki.
- [Wprowadzenie do Model Context Protocol](https://developertoolkit.ai/pl/ecosystem/mcp/): MCP we wrześniu 2026: specyfikacja 2026-07-28, zdalne serwery z OAuth, rejestr w wersji preview i bezpieczne dodanie serwera w Claude Code, Codex i Cursorze.
- [Atlassian Rovo MCP: Jira, Confluence i Bitbucket z poziomu agenta](https://developertoolkit.ai/pl/ecosystem/mcp/atlassian-mcp/): Podłącz Claude Code, Codex lub Cursor do Jiry, Confluence i Bitbucketa przez serwer /v2/mcp: OAuth lub token API, kontrola admina, śledzenie wymagań.
- [Automatyzacja przeglądarki dla agentów: Playwright, Chrome DevTools, Browser Use, Stagehand i agent-browser](https://developertoolkit.ai/pl/ecosystem/mcp/browser-automation/): Dobierz narzędzie przeglądarkowe dla agenta: Playwright MCP, Chrome DevTools MCP, agent-browser, dev-browser, Browser Use lub Stagehand, zależnie od zadania.
- [Serwery MCP chmur i platform: AWS, Azure, Google Cloud, Vercel i Stripe](https://developertoolkit.ai/pl/ecosystem/mcp/cloud-platform-mcp/): Podłącz Claude Code, Codeksa i Cursora do AWS, Azure, Google Cloud, Vercela i Stripe'a przez tożsamości tylko do odczytu, przypięte wersje i twarde dowody.
- [Cloudflare MCP: Code Mode i serwery domenowe](https://developertoolkit.ai/pl/ecosystem/mcp/cloudflare-mcp/): Podłącz serwer Code Mode i serwery domenowe Cloudflare do Claude Code, Codeksa i Cursora: OAuth czy token, limity wyników i migracja D1 krok po kroku.
- [Serwery MCP, które rozumieją twój kod: Serena, codebase-memory-mcp, Claude Context i Repomix](https://developertoolkit.ai/pl/ecosystem/mcp/code-intelligence-mcp/): Nawigacja po symbolach dla Claude Code, Codeksa i Cursora: zainstaluj Serenę, codebase-memory-mcp, Claude Context lub Repomix i zrób bezpieczny refaktor.
- [Context7: aktualna dokumentacja bibliotek dla agenta (MCP, CLI i tryb skills)](https://developertoolkit.ai/pl/ecosystem/mcp/context7/): Context7 w Claude Code, Codex i Cursorze: przypinanie ID bibliotek, wybór między MCP a trybem skills i dowód, że agent pisał pod aktualne API.
- [Tworzenie własnego serwera MCP](https://developertoolkit.ai/pl/ecosystem/mcp/custom-mcp-development/): Zbuduj serwer MCP dla wewnętrznego API na SDK v2, obsłuż spec 2026-07-28 i starszych klientów, przetestuj go bez czytania każdej linii i wydaj.
- [Serwery MCP dla baz danych: Postgres MCP Pro, DBHub, MCP Toolbox, Supabase, Neon i MongoDB](https://developertoolkit.ai/pl/ecosystem/mcp/database-mcp/): Podłącz Claude Code, Codex i Cursora do Postgresa, Supabase, Neona lub MongoDB tylko do odczytu, znajdź wolne zapytania i wdrażaj zmiany schematu przez CI.
- [Figma MCP: od projektu do kodu w 2026 roku](https://developertoolkit.ai/pl/ecosystem/mcp/design-tools-mcp/): Podłącz zdalny serwer MCP Figmy do Claude Code, Codeksa i Cursora, użyj swoich komponentów przez Code Connect i udowodnij, że kod zgadza się z ramką.
- [Serwer MCP AI Developer Toolkit](https://developertoolkit.ai/pl/ecosystem/mcp/developertoolkit-mcp/): Podłącz Claude Code, Codeksa albo Cursora do przewodników z tego serwisu przez publiczny endpoint MCP: dwa narzędzia, bez konta i bez klucza API.
- [Startowy zestaw MCP na 2026: pięć serwerów, których potrzebuje większość zespołów](https://developertoolkit.ai/pl/ecosystem/mcp/essential-servers/): Pięć serwerów MCP na 2026 (GitHub, Context7, Playwright, Linear lub Atlassian, Sentry): komendy instalacji dla trzech agentów i pętla od błędu do PR.
- [Serwery MCP środowiska deweloperskiego: Next.js DevTools, MobileBuildMCP i Hugging Face](https://developertoolkit.ai/pl/ecosystem/mcp/framework-devtools-mcp/): Podłącz Next.js DevTools MCP, MobileBuildMCP i Hugging Face MCP do Claude Code, Codeksa i Cursora, aby błędy buildu, testów i runtime trafiały do agenta.
- [Serwer GitHub MCP: zdalnie, lokalnie, toolsety i tryb lockdown](https://developertoolkit.ai/pl/ecosystem/mcp/github-mcp/): Serwer GitHub MCP w Claude Code, Codex i Cursorze: zdalnie czy Docker, uprawnienia PAT, adresy toolsetów, tryb lockdown, naprawa CI i GitLab MCP.
- [MCP dla infrastruktury: Docker MCP Toolkit, Kubernetes i Terraform](https://developertoolkit.ai/pl/ecosystem/mcp/infrastructure-mcp/): Podłącz serwery MCP Kubernetesa i Terraforma tylko do odczytu, zdiagnozuj CrashLoopBackOff i przeprowadź zmianę IaC od rejestru do przejrzanego planu w HCP.
- [Jeden serwer, wiele aplikacji: Composio i n8n-mcp](https://developertoolkit.ai/pl/ecosystem/mcp/integration-hubs-mcp/): Podłącz Composio z zarządzanym OAuth do wielu aplikacji SaaS, a n8n-mcp użyj do budowy i walidacji workflowów n8n. Kiedy jeden hub wygrywa z pięcioma serwerami.
- [Najlepsze praktyki MCP: budżet kontekstu, szybkość i agenci równolegli](https://developertoolkit.ai/pl/ecosystem/mcp/mcp-best-practices/): Serwery MCP szczupłe, szybkie i bezpieczne dla agentów równoległych: pomiar kosztu kontekstu, limity wyników, przypięte wersje, osobne profile i test zdrowia.
- [Problemy z połączeniem serwera MCP](https://developertoolkit.ai/pl/ecosystem/mcp/mcp-connection-issues/): Napraw serwery MCP, które nie działają w Claude Code, Codeksie lub Cursorze: spawn ENOENT, brak zatwierdzenia, 401, timeouty i pułapki CLI.
- [Bezpieczeństwo serwerów MCP: skanowanie, tryby tylko do odczytu i prompt injection](https://developertoolkit.ai/pl/ecosystem/mcp/mcp-security/): Skanuj konfiguracje MCP i skille narzędziem Snyk Agent Scan, włącz tryby tylko do odczytu, ogranicz prompt injection i wprowadź zespołową akceptację MCP.
- [Mobbin MCP: prawdziwe przykłady designu dla agentów AI](https://developertoolkit.ai/pl/ecosystem/mcp/mobbin-mcp/): Podłącz Claude Code, Codex lub Cursora do biblioteki ekranów z wydanych aplikacji Mobbina, zbadaj wzorce UI przed budową i sprawdź wynik względem nich.
- [Debugowanie produkcji z edytora: Sentry, Grafana, Datadog i PostHog MCP](https://developertoolkit.ai/pl/ecosystem/mcp/observability-mcp/): Podłącz Sentry, Grafanę, Datadoga i PostHog MCP do Claude Code, Codeksa i Cursora tylko do odczytu, napraw główny błąd produkcji i sprawdź go po wdrożeniu.
- [Playwright MCP kontra Playwright CLI: testy w przeglądarce dla agentów](https://developertoolkit.ai/pl/ecosystem/mcp/playwright-mcp/): Playwright MCP czy Playwright CLI ze skillem? Ustaw --isolated dla równoległych agentów i zamień zgłoszenie błędu w test E2E: czerwony, zielony, CI.
- [Zgłoszenia i dokumentacja przez MCP: Linear, Jira, Notion i Slack](https://developertoolkit.ai/pl/ecosystem/mcp/project-management/): Podłącz Claude Code, Codex lub Cursor do Linear, Jiry, Notion i Slacka przez MCP i przeprowadź zgłoszenie aż do PR, z dowodami w zgłoszeniu.
- [Jak obniżyć koszt tokenów MCP: Code Mode, context-mode i ścieżka CLI + skill](https://developertoolkit.ai/pl/ecosystem/mcp/reducing-mcp-token-cost/): Obniż koszt kontekstu MCP w Claude Code, Codeksie i Cursorze: ctx_execute z context-mode, Cloudflare Code Mode, toolsety GitHuba i zamiana na CLI + skill.
- [Referencyjne serwery MCP i kiedy ich nie potrzebujesz](https://developertoolkit.ai/pl/ecosystem/mcp/reference-servers/): Siedem serwerów referencyjnych MCP, te zarchiwizowane i ich następcy oraz audyt .mcp.json „najpierw narzędzia natywne” dla Claude Code, Codex i Cursora.
- [Rejestry i bramki MCP: dopuszczanie serwerów w organizacji](https://developertoolkit.ai/pl/ecosystem/mcp/registry-and-gateways/): Weryfikuj serwery MCP w oficjalnym rejestrze, prowadź katalog zatwierdzonych, egzekwuj go w Claude Code, Codex i Cursorze, a wywołania audytuj przez bramkę.
- [Serwer MCP shadcn/ui](https://developertoolkit.ai/pl/ecosystem/mcp/shadcn-ui-mcp/): Skonfiguruj oficjalny serwer MCP shadcn w Claude Code, Codeksie i Cursorze, połącz go ze skillem shadcn i sprawdzaj komponenty testami, nie czytaniem.
- [MCP 2026-07-28: co się zmieniło i jak zmigrować serwer](https://developertoolkit.ai/pl/ecosystem/mcp/spec-2026-07-28/): MCP 2026-07-28 usuwa handshake i sesje, dodaje server/discover. Co psuje się we własnym serwerze, jak go zmigrować i jak przetestować obie ery.
- [Najlepsze społecznościowe serwery MCP i jak je sprawdzić](https://developertoolkit.ai/pl/ecosystem/mcp/top-community-servers/): Społecznościowe serwery MCP warte instalacji w 2026 roku, od Serena i Repomix po DBHub, oraz 15-minutowa weryfikacja, zanim zespół im zaufa.
- [30 najważniejszych serwerów MCP dla zespołów programistycznych — ranking (wrzesień 2026)](https://developertoolkit.ai/pl/ecosystem/mcp/top-mcp-servers/): Ranking 30 serwerów MCP: oficjalne czy społecznościowe, zdalne czy lokalne, przełącznik tylko do odczytu każdego i zestaw startowy dla typu zespołu.
- [Wyszukiwanie i scraping przez MCP: Firecrawl, Exa, Tavily, Brave i MarkItDown](https://developertoolkit.ai/pl/ecosystem/mcp/web-research-mcp/): Wybierz i zainstaluj serwery MCP do wyszukiwania, scrapingu i konwersji w Claude Code, Codex i Cursorze, a źródła zamień w sprawdzony ADR z cytatami.
- [Porównanie modeli AI dla agentów kodujących](https://developertoolkit.ai/pl/ecosystem/models/): Modele, ceny i ustawienia domyślne w Claude Code, Codex i Cursorze (stan na 2026-10-12) oraz zasada wyboru: model domyślny, potem effort, potem ewaluacje.
- [Jak czytać benchmarki agentów kodujących i budować własne ewaluacje](https://developertoolkit.ai/pl/ecosystem/models/benchmarks/): Co mierzą, a czego nie widzą SWE-bench Verified, SWE-bench Pro, Terminal-Bench 4.0 i tabele producentów oraz jak zbudować 30 zadań, które wybiorą model.
- [Nowy model na rynku: plan oceny w 48 godzin](https://developertoolkit.ai/pl/ecosystem/models/new-model-playbook/): Procedura na 48 godzin po premierze modelu: przypnij konfigurację, powtórz ewaluacje, porównaj jakość, koszt i czas, dostrój rozumowanie, wdrażaj pętlami.
- [Modele open-weight i hostowane samodzielnie dla agentów kodujących](https://developertoolkit.ai/pl/ecosystem/models/open-weight/): GLM, Qwen, Kimi, DeepSeek i Mistral w sieciach bez internetu: licencje, które harnessy je przyjmują, jak je serwować i jak zmierzyć lukę na własnych ewaluacjach.
- [Pomiar pracy z agentami: telemetria, koszty, review, bezpieczeństwo i ewaluacje](https://developertoolkit.ai/pl/ecosystem/observability/): Mierz agentów w trzech warstwach: wbudowana telemetria, lokalne liczniki kosztów, platformy ewaluacji i śledzenia. Co włączyć najpierw i cotygodniowy raport.
- [Ile kosztowali agenci? ccusage, /usage, monitory i budżety w bramkach](https://developertoolkit.ai/pl/ecosystem/observability/agent-cost-tracking/): Jak śledzić koszty Claude Code, Codeksa i Cursora: /usage, ccusage, monitory i budżety zespołów w LiteLLM, Cloudflare AI Gateway lub claude gateway.
- [Bramki bezpieczeństwa dla kodu pisanego przez agentów: Semgrep, Gitleaks, TruffleHog, Snyk i Claude Security Review](https://developertoolkit.ai/pl/ecosystem/observability/agent-security-gates/): Zatrzymaj sekrety i podatny kod w commitach agentów: hook pre-commit z Gitleaks, Semgrep i TruffleHog w CI oraz security review od Claude na każdym PR.
- [OpenTelemetry i analityka dla Claude Code, Codex i Cursor](https://developertoolkit.ai/pl/ecosystem/observability/agent-telemetry/): Wyślij telemetrię Claude Code i Codeksa do lokalnego stosu Grafany, poznaj granice dashboardów analitycznych i powiąż commity z sesjami przez Entire CLI.
- [Boty do AI code review: Claude Code Review, Codex, Bugbot, CodeRabbit, Greptile i inne](https://developertoolkit.ai/pl/ecosystem/observability/ai-code-review-bots/): 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.
- [Ewaluacja agentów, promptów i zmian w CLAUDE.md: promptfoo, Inspect SWE, Langfuse i Braintrust](https://developertoolkit.ai/pl/ecosystem/observability/evals-coding-agents/): Test A/B zmiany w CLAUDE.md lub AGENTS.md na stałym zestawie zadań w promptfoo lub Inspect SWE i śledzenie nieudanych sesji w Langfuse lub Braintrust.
- [Pluginy i marketplace'y w Claude Code, Codex i Cursorze](https://developertoolkit.ai/pl/ecosystem/plugins/): Co zawiera plugin, czym różnią się marketplace'y Claude Code, Codex, Cursora i Copilot CLI oraz jak zespół mierzy, przypina i dopuszcza pluginy.
- [Pluginy deweloperskie Anthropic: code-review, feature-dev, pr-review-toolkit, security-guidance i inne](https://developertoolkit.ai/pl/ecosystem/plugins/anthropic-dev-plugins/): 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.
- [Budowa i dystrybucja pluginu lub prywatnego marketplace'u](https://developertoolkit.ai/pl/ecosystem/plugins/building-plugins/): Zbuduj plugin ze skillem, hookiem i serwerem MCP, udowodnij jego działanie przez validate i eval, wersjonuj go i wydaj w prywatnym marketplace zespołu.
- [Marketplace'y i rejestry: skąd biorą się pluginy, skille i serwery MCP](https://developertoolkit.ai/pl/ecosystem/plugins/marketplaces-registries/): Z którego marketplace'u lub rejestru brać plugin, skill albo serwer MCP w Claude Code, Codeksie, Cursorze i Copilocie, co dowodzi wpis i jak go sprawdzić.
- [Trwała pamięć agentów: claude-mem, planning-with-files i serwery MCP pamięci](https://developertoolkit.ai/pl/ecosystem/plugins/memory-plugins/): Utrzymaj wielodniowe zadanie agenta mimo /clear dzięki planning-with-files, a claude-mem, serwer MCP Memory i basic-memory dodaj tylko tam, gdzie się opłacają.
- [Prywatny marketplace wtyczek dla zespołu](https://developertoolkit.ai/pl/ecosystem/plugins/team-marketplace/): Prywatny marketplace wtyczek dla Claude Code, Codexa i Cursora: układ repo, zastrzeżone nazwy, reguła wersji, dostęp, walidacja w CI i wdrożenie.
- [Pluginy warte instalacji, z przykładami użycia](https://developertoolkit.ai/pl/ecosystem/plugins/top-plugins/): 20 najczęściej instalowanych pluginów Claude Code: zmierzony koszt kontekstu, do czego mają dostęp, wersje dla Codeksa i Cursora oraz przykład dla każdego.
- [Wprowadzenie do Agent Skills](https://developertoolkit.ai/pl/ecosystem/skills/): Agent Skills to foldery SKILL.md ładowane na żądanie przez Claude Code, Codex i Cursora: plugin czy przenośna kopia, gdzie agent ich szuka i przypinanie.
- [agent-browser: agent sprawdza działającą aplikację](https://developertoolkit.ai/pl/ecosystem/skills/agent-browser/): Zainstaluj CLI i skill agent-browser w Claude Code, Codex i Cursorze, uruchom pętlę sprawdzania w przeglądarce i dołączaj zrzuty ekranu jako dowody do PR.
- [Budowanie i publikowanie własnych skilli](https://developertoolkit.ai/pl/ecosystem/skills/building-custom-skills/): Utwórz SKILL.md przez npx skills init, claude plugin init lub skill-creator, sprawdź go validate --strict i plugin eval, a potem opublikuj i przypnij.
- [Code review wewnątrz agenta: skille i wtyczki](https://developertoolkit.ai/pl/ecosystem/skills/code-review-skills/): Wbudowane /code-review, wtyczki code-review i pr-review-toolkit oraz skille do code review od Pococka, Superpowers, Trail of Bits i CodeRabbit, i jak je łączyć.
- [Skille do dyscypliny kontekstu i tokenów: caveman, handoff, karpathy-guidelines](https://developertoolkit.ai/pl/ecosystem/skills/context-and-token-skills/): Zainstaluj caveman, handoff i karpathy-guidelines w Claude Code, Codex i Cursorze, przekaż pracę przy 70% kontekstu i wznawiaj długie zadania bez strat.
- [Dokumenty i pisanie: skille Office, doc-coauthoring i writing-guidelines](https://developertoolkit.ai/pl/ecosystem/skills/document-and-writing-skills/): Skille docx, pdf, pptx i xlsx od Anthropic, doc-coauthoring, writing-guidelines Vercela i humanizer: instalacja i łańcuch od szkicu RFC do prezentacji.
- [Dr. Skill: audyt loadoutu skilli i MCP twojego agenta](https://developertoolkit.ai/pl/ecosystem/skills/drskill/): drskill 0.8.1 pokazuje, jakie skille, skille z wtyczek i serwery MCP ładuje każdy agent, wykrywa konflikty i zbędny balast oraz pilnuje loadoutu w CI.
- [Skille Matta Pococka: od grill-me do implement](https://developertoolkit.ai/pl/ecosystem/skills/grill-me/): Instalacja skilli Matta Pococka w Claude Code, Codeksie i Cursorze oraz cały łańcuch: grill-me, to-spec, to-tickets, implement z tdd i code-review.
- [Impeccable: słownik projektowy dla twojego agenta AI](https://developertoolkit.ai/pl/ecosystem/skills/impeccable-design/): Zainstaluj Impeccable, daj agentowi wspólny słownik projektowy i sprawdzaj generowany przez AI interfejs deterministycznym detektorem w hookach i w CI.
- [Instalowanie, udostępnianie i przypinanie skilli w zespole](https://developertoolkit.ai/pl/ecosystem/skills/installing-managing/): Instaluj Agent Skills przez CLI skills 1.7.0, przypinaj je do refa w Git, udostępniaj przez repozytorium i omijaj pułapki instalujące zły zestaw.
- [shadcn/improve: audytuj najlepszym modelem, wykonuj tanim](https://developertoolkit.ai/pl/ecosystem/skills/shadcn-improve/): Zainstaluj shadcn/improve, zaudytuj repo najmocniejszym modelem, zamień wyniki w samodzielne plany i oddaj je tańszemu wykonawcy, którego pracę zweryfikujesz.
- [Bezpieczeństwo łańcucha dostaw Skills](https://developertoolkit.ai/pl/ecosystem/skills/skill-security/): Sprawdź skill, zanim agent go załaduje: rozpoznaj podróbki repozytoriów, przeskanuj SKILL.md narzędziem Snyk Agent Scan, przeczytaj hooki, wymuś allowlistę.
- [Taste Skill: biblioteka anty-slop skilli frontendowych](https://developertoolkit.ai/pl/ecosystem/skills/taste-skill/): Zainstaluj Taste Skill w Claude Code, Codeksie albo Cursorze, steruj generowaniem landing page'y pokrętłami i listą zakazów, a wynik sprawdzaj w CI.
- [Skille, które uczą agenta porządnie testować i debugować](https://developertoolkit.ai/pl/ecosystem/skills/testing-debugging-skills/): Zainstaluj tdd, diagnosing-bugs, systematic-debugging i verification-before-completion w Claude Code, Codex i Cursorze i udowadniaj każdą poprawkę.
- [25 najczęściej instalowanych skilli praktyk programistycznych (wrzesień 2026)](https://developertoolkit.ai/pl/ecosystem/skills/top-practice-skills/): 25 najczęściej instalowanych skilli praktyk dla Claude Code, Codeksa i Cursora, startowe trio dla nowego repo i łączenie ich w zweryfikowaną pętlę.
- [Najlepsze skille backendowe i DevOps: bazy, uwierzytelnianie, chmura, IaC](https://developertoolkit.ai/pl/ecosystem/skills/top-skills-backend/): Skille dostawców: Supabase, Neon, Clerk, Better Auth, Cloudflare, AWS, Stripe, Terraform. Instalacja w każdym narzędziu, koszt kontekstu i workflow nowej usługi.
- [Skille do produktu, marketingu i pracy z wiedzą](https://developertoolkit.ai/pl/ecosystem/skills/top-skills-business/): Marketing Skills, last30days, skille Obsidiana i Google Workspace dla agentów: audyt CRO strony /pricing, checklista premiery i weryfikacja wyników.
- [Najlepsze skille frontendowe: design, React, Next.js i mobile](https://developertoolkit.ai/pl/ecosystem/skills/top-skills-frontend/): Skille frontendowe warte instalacji w 2026 (design, React, Next.js, Expo, Remotion) i pętla od design systemu do śladu wydajności, która dowodzi jakości UI.
- [Oficjalne skille dostawców: kto co publikuje (wrzesień 2026)](https://developertoolkit.ai/pl/ecosystem/skills/top-skills-official/): Którzy dostawcy publikują oficjalne skille, z jakich repozytoriów je instalować w Claude Code, Codex i Cursorze, co nie jest oficjalne i jak je aktualizować.
- [Skille anty-slop: unslop, miodkuj i co mówią ewaluacje](https://developertoolkit.ai/pl/ecosystem/skills/unslop/): Wyłapuj ślady AI w dokumentacji skanerami unslopa jako bramką CI, poprawiaj polszczyznę miodkujem i sprawdź, czego naprawdę dowodzą ewaluacje tych projektów.

## Cookbook

- [Książka kucharska programisty pracującego z AI](https://developertoolkit.ai/pl/cookbook/): Receptury do skopiowania dla Claude Code, Codeksa i Cursora według stosu, każda z testem, typami lub buildem, które dowodzą wyniku agenta.
- [Receptury backendowe](https://developertoolkit.ai/pl/cookbook/backend-recipes/): Wybierz recepturę backendową dla swojego stosu, zapisz bramkę w AGENTS.md i udowadniaj poprawność kodu agenta testami zamiast czytania każdej linii.
- [Wzorce tworzenia API](https://developertoolkit.ai/pl/cookbook/backend-recipes/api-patterns/): Prompty dla Claude Code, Codex i Cursora, które budują idempotentne POST-y, paginację keyset i OpenAPI bez dryfu, plus testy, które to udowadniają.
- [Receptury .NET i C#](https://developertoolkit.ai/pl/cookbook/backend-recipes/dotnet-patterns/): Receptury dla agentów w ASP.NET Core, EF Core i xUnit v3 — jeden AGENTS.md, pętle test-first na prawdziwym Postgresie i analizatory, które blokują build.
- [Receptury na Elixira i Phoenix](https://developertoolkit.ai/pl/cookbook/backend-recipes/elixir-patterns/): Receptury dla agentów w Phoenix 1.8 i Elixir 1.20: mix precommit jako bramka, Tidewave MCP, strumienie LiveView, testy OTP, Ecto.Multi, Oban i release'y.
- [Wzorce języka Go](https://developertoolkit.ai/pl/cookbook/backend-recipes/go-patterns/): Prompty i bramki dla usług Go pisanych przez agenta — graceful shutdown, ograniczone goroutines, dobrane pule pgx oraz testy wyścigów i wycieków.
- [Wzorce Java i Spring Boot](https://developertoolkit.ai/pl/cookbook/backend-recipes/java-patterns/): Kod Spring Boot 4.1 z Claude Code, Codexa lub Cursora bez usuniętych API, zapytań N+1 i połykanych błędów, udowodniony Testcontainers i ArchUnit.
- [Przepisy na Node.js/Express](https://developertoolkit.ai/pl/cookbook/backend-recipes/node-patterns/): Prompty i bramki dla usług Node.js na Express 5 pisanych przez agenta: czysty shutdown, walidacja, rotacja tokenów, transakcje Prisma, kolejki i logi.
- [Wzorce programowania w PHP](https://developertoolkit.ai/pl/cookbook/backend-recipes/php-patterns/): Receptury dla agentów w Laravelu 13 i Symfony — kontekst z Laravel Boost, testy najpierw, bramka Pint, PHPStan i PHPUnit, ścisły Eloquent i bezpieczne legacy.
- [Przepisy na Python](https://developertoolkit.ai/pl/cookbook/backend-recipes/python-patterns/): Prompty i bramki dla backendów Python pisanych przez agenta: lifespan FastAPI, Pydantic v2, async SQLAlchemy 2.1, Celery, httpx, structlog i izolacja tenantów.
- [Receptury Ruby on Rails](https://developertoolkit.ai/pl/cookbook/backend-recipes/ruby-rails-patterns/): Receptury dla agentów w Rails 8.1 — generatory zamiast ręcznych plików, pętle RSpec, bin/ci jako definicja ukończenia, bezpieczne migracje i wykrywanie N+1.
- [Wzorce programowania w Rust](https://developertoolkit.ai/pl/cookbook/backend-recipes/rust-patterns/): Prompty i bramki dla usług Rust pisanych przez agenta — ownership bez klonowania, błędy mapowane na HTTP, sprawdzany SQLx i czyste zamykanie Tokio.
- [Wzorce serverless dla agentów AI](https://developertoolkit.ai/pl/cookbook/backend-recipes/serverless-patterns/): Przepisy dla agentów AI na AWS Lambda, Cloudflare Workers i Vercel — idempotentne handlery, kontrola bindingów, cold starty i testy, które to dowodzą.
- [Receptury inżynierii danych](https://developertoolkit.ai/pl/cookbook/data-recipes/): Gotowe receptury na modele dbt, potoki SQL, notatniki i testy danych w Claude Code, Codeksie i Cursorze, każda udowodniona przez dbt build na targecie dev.
- [Przepisy bazodanowe](https://developertoolkit.ai/pl/cookbook/database-recipes/): Przepisy na migracje, kod ORM, strojenie SQL i modele NoSQL: agent pracuje na prawdziwym schemacie, a każdą zmianę udowadnia prawdziwy silnik bazy.
- [Wzorce migracji baz danych](https://developertoolkit.ai/pl/cookbook/database-recipes/migration-patterns/): Migracje Postgresa bez przestojów w Claude Code, Codeksie i Cursorze, udowodnione linterem Squawk, zapytaniem zgodności i planem wycofania każdej fazy.
- [Wzorce i strategie NoSQL](https://developertoolkit.ai/pl/cookbook/database-recipes/nosql-patterns/): Projektuj modele danych MongoDB, DynamoDB, Neo4j i wektorowe z Claude Code, Codeksem lub Cursorem według wzorców dostępu i dowodź każdego zapytania testem.
- [Najlepsze praktyki ORM](https://developertoolkit.ai/pl/cookbook/database-recipes/orm-patterns/): Kod Prisma 7 i TypeORM 1.x od Claude Code, Codeksa lub Cursora bez sprzedaży ponad stan, N+1 i usuniętych API, sprawdzony na prawdziwym Postgresie.
- [Wzorce optymalizacji SQL](https://developertoolkit.ai/pl/cookbook/database-recipes/sql-patterns/): Przyspiesz wolne zapytania w Postgresie i MySQL z Claude Code, Codeksem i Cursorem, a każdy indeks, przepisanie i poprawkę N+1 udowodnij planem i testem.
- [Przepisy DevOps i infrastruktury](https://developertoolkit.ai/pl/cookbook/devops-recipes/): Wybierz przepis DevOps na Dockera, Kubernetes, CI/CD, IaC lub monitoring, daj agentowi reguły dostarczania i udowodnij każdą zmianę bramkami.
- [Wzorce pipeline'ów CI/CD](https://developertoolkit.ai/pl/cookbook/devops-recipes/ci-cd-pipelines/): Receptury, dzięki którym Claude Code, Codex i Cursor generują pipeline'y CI/CD z bramkami, które naprawdę blokują zmianę, i sposób, by to udowodnić.
- [Wzorce Docker i kontenerów](https://developertoolkit.ai/pl/cookbook/devops-recipes/docker-patterns/): Receptury na Dockerfile, pliki Compose i CI obrazów pisane przez Claude Code, Codex i Cursora oraz skrypt, który sprawdza każdy obraz przed merge'em.
- [Wzorce infrastruktury jako kod](https://developertoolkit.ai/pl/cookbook/devops-recipes/infrastructure-as-code/): Receptury na Terraform, CloudFormation i Pulumi pisane przez agenta, z poświadczeniami tylko do planu, maszynową bramką planu i ludzką zgodą na usunięcia.
- [Wzorce orkiestracji Kubernetes](https://developertoolkit.ai/pl/cookbook/devops-recipes/kubernetes-patterns/): Niech Claude Code, Codex lub Cursor piszą manifesty Kubernetes i charty Helm, a ty udowadniasz je bramkami kubeconform, dry-run po stronie serwera i diff.
- [Wzorce monitorowania i logowania](https://developertoolkit.ai/pl/cookbook/devops-recipes/monitoring-logging/): Receptury dla agentów na alerty złotych sygnałów i burn-rate SLO, routing Alertmanagera, korelację logów ze śladami i tail sampling, każda z testem.
- [Przepisy obsługi błędów](https://developertoolkit.ai/pl/cookbook/error-handling-recipes/): Wybierz przepis na debugowanie, logowanie, odzyskiwanie lub monitoring, daj agentowi reguły błędów i udowodnij poprawkę testem, który najpierw padł.
- [Wzorce debugowania](https://developertoolkit.ai/pl/cookbook/error-handling-recipes/debugging-patterns/): Pięć receptur debugowania z agentem na sporadyczne błędy, ślady stosu, wycieki, wyścigi i błędy między usługami, każda ze sprawdzeniem przed poprawką i po niej.
- [Wzorce logowania](https://developertoolkit.ai/pl/cookbook/error-handling-recipes/logging-patterns/): Receptury dla agentów AI zamieniające console.log w strukturalne, skorelowane i zredagowane logi Node.js, sprawdzane testem kontraktu, kanarkiem i lintem.
- [Wzorce odzyskiwania](https://developertoolkit.ai/pl/cookbook/error-handling-recipes/recovery-patterns/): Receptury dla agentów AI na circuit breakery, ponowienia i fallbacki z opossum i cockatiel, sprawdzane testem kontraktu, który celowo otwiera obwód.
- [Przepisy frontendowe](https://developertoolkit.ai/pl/cookbook/frontend-recipes/): Wybierz przepis dla swojego frameworka, daj agentowi przeglądarkę i udowadniaj pracę nad UI testami, skanem a11y i zrzutami ekranu, a nie czytaniem kodu.
- [Przepisy na Angulara](https://developertoolkit.ai/pl/cookbook/frontend-recipes/angular-patterns/): Prompty do wklejenia, z którymi Claude Code, Codex i Cursor piszą Angular 22: sygnały, Signal Forms, zoneless, SSR, sprawdzone buildem, Vitestem i E2E.
- [Przepisy optymalizacji Next.js](https://developertoolkit.ai/pl/cookbook/frontend-recipes/nextjs-patterns/): Prompty do kodu Next.js 16 App Router z Claude Code, Codexa lub Cursora oraz bramki build, typów i Playwrighta, które dowodzą, że działa.
- [Przepisy na Nuxt 4 z agentami AI](https://developertoolkit.ai/pl/cookbook/frontend-recipes/nuxt-patterns/): Prompty, które dają kod Nuxt 4 z Claude Code, Codeksa lub Cursora, z serwerem MCP dokumentacji Nuxt i bramkami typów, testów i builda.
- [Przepisy dla Reacta](https://developertoolkit.ai/pl/cookbook/frontend-recipes/react-patterns/): Gotowe prompty do pracy z React 19 w Claude Code, Codex i Cursor: z Figmy do kodu, tabele TanStack v9, formularze, optymistyczne UI i bramki.
- [Przepisy workflow Vue.js](https://developertoolkit.ai/pl/cookbook/frontend-recipes/vue-patterns/): Gotowe prompty do pracy z Vue 3.5 w Claude Code, Codex i Cursor: store’y Pinia 4, composables, formularze, trasy, i18n oraz bramki, które je sprawdzają.
- [Rozwój mobilny](https://developertoolkit.ai/pl/cookbook/mobile-development/): Przepisy mobilne dla Claude Code, Codex i Cursora: wybierz Expo, React Native, Fluttera lub natywne, zainstaluj skille stosu i weryfikuj na symulatorach.
- [Wzorce rozwoju Expo](https://developertoolkit.ai/pl/cookbook/mobile-development/expo/): Expo SDK 57 z Claude Code, Codeksem i Cursorem: skille i MCP od Expo, bramki logowania w Expo Router, pipeline EAS sterowany fingerprintem i bezpieczne OTA.
- [Wzorce programowania we Flutterze](https://developertoolkit.ai/pl/cookbook/mobile-development/flutter/): Flutter z Claude Code, Codeksem i Cursorem: oficjalny plugin Dart i Flutter, Riverpod 3 z codegenem, go_router, Dio i bramka sprawdzająca każdą zmianę.
- [Przepisy UI dla React Native i Flutter](https://developertoolkit.ai/pl/cookbook/mobile-development/mobile-patterns/): 12 promptów dla agenta do UI w React Native i Flutterze, przypiętych do aktualnych wersji pakietów, każdy z dowodem z urządzenia, że działa.
- [Receptury natywne: iOS i Android](https://developertoolkit.ai/pl/cookbook/mobile-development/native-ios-android/): Swift/SwiftUI i Kotlin/Compose z agentem: jeden skrypt build-i-test na platformę, pętle symulatora i emulatora, szybkie buildy i dowody z testów UI.
- [Wzorce rozwoju React Native](https://developertoolkit.ai/pl/cookbook/mobile-development/react-native/): React Native z Claude Code, Codeksem i Cursorem: stan offline-first, FlashList v2, bramka biometryczna, debugowanie buildu release i bramki, które to dowodzą.

## Lead a team

- [Zespół: prowadzenie zespołu, który dowozi z agentami](https://developertoolkit.ai/pl/teams/): Dla tech leadów: wdrożenie agentów w całym zespole, jeden wspólny harness, płynna kolejka code review i przekonanie sceptyków, seniorów oraz juniorów.
- [Wdrożenie agentów kodujących w zespole](https://developertoolkit.ai/pl/teams/adopt/): Dla tech leadów: w jakiej kolejności przebiega wdrożenie agentów kodujących w zespole, która strona opisuje każdy krok i jakie dowody pokazują, że wdrożenie działa.
- [Mapa adopcji dla jednego repozytorium: przejścia po drabinie pętla po pętli](https://developertoolkit.ai/pl/teams/adopt/adoption-roadmap/): Przesuwaj pętle dostarczania jednego repozytorium po drabinie autonomii o jeden szczebel: zmiany w repo, dowody bramki, prompty i reguła wycofania.
- [Migracja między Codexem, Cursorem i Claude Code](https://developertoolkit.ai/pl/teams/adopt/from-codex/): Przenieś repozytorium między Codexem, Claude Code i Cursorem: jeden AGENTS.md, wbudowane importery, konfiguracja MCP dla każdego narzędzia i test porównawczy.
- [Claude Code lub Codex obok GitHub Copilota](https://developertoolkit.ai/pl/teams/adopt/from-copilot/): Zostaw GitHub Copilot i dodaj Claude Code lub Codex: jeden AGENTS.md, wspólne skille i MCP, dwutygodniowy pilotaż i te same bramki CI dla PR każdego agenta.
- [Migracja z tradycyjnych IDE](https://developertoolkit.ai/pl/teams/adopt/from-traditional-ide/): Z VS Code, JetBrains lub Vima do Cursora, Claude Code lub Codeksa: zachowaj edytor, dodaj jeden plik instrukcji i sprawdzaj każdy diff agenta bramkami.
- [Migracja z Devin Desktop (dawniej Windsurf)](https://developertoolkit.ai/pl/teams/adopt/from-windsurf/): Przenieś repo z Windsurf lub Devin Desktop do Claude Code, Codexa albo Cursora: reguły według triggera, workflow jako skille, MCP i dowód działania reguł.
- [Playbook konwersji projektu](https://developertoolkit.ai/pl/teams/adopt/project-conversion/): Przygotuj istniejące repozytorium dla Claude Code, Codeksa i Cursora: jeden AGENTS.md z prawdziwego kodu, cienkie adaptery, kontrole w CI i pilotaż przed/po.
- [Onboarding i adopcja w zespole, pętla po pętli](https://developertoolkit.ai/pl/teams/adopt/team-adoption/): Dla tech leadów: wdrażaj zespół do pracy z agentami pętla po pętli, z właścicielem pętli, wspólnym harnessem, miarą efektywnego użycia i regułami wycofania.
- [Współpraca zespołowa: wspólny kontekst i reguły](https://developertoolkit.ai/pl/teams/adopt/team-collaboration/): Daj agentom Claude Code, Codex i Cursor każdego inżyniera ten sam kontekst zespołu: wspólne reguły, pętlę z review do reguł, plany w repo i dowód wczytania.
- [Transformacja przepływu pracy: dostarczanie funkcji przebudowane pod agentów](https://developertoolkit.ai/pl/teams/adopt/workflow-transformation/): Dla tech leadów: przebuduj pętlę od ticketu do merge'a tak, by agenci pisali plan, kod i testy, a ludzie decydowali o celu, akceptacji i ryzyku.
- [Jak przygotować backlog dla agentów](https://developertoolkit.ai/pl/teams/agent-ready-backlog/): Które zadania oddać agentom: test kwalifikacji (wyrocznia, zasięg, odwracalność), cięcie pracy, szablon zgłoszenia i cztery tory pracy.
- [Rozwój juniorów, gdy kod piszą agenci](https://developertoolkit.ai/pl/teams/junior-developers/): Dla tech leadów i CTO: co junior wciąż ćwiczy ręcznie, code review jako nauka, pisanie specyfikacji jako trening i ryzyko niezatrudniania juniorów.
- [Jak utrzymać zespół na bieżąco, gdy narzędzia zmieniają się co tydzień](https://developertoolkit.ai/pl/teams/keeping-current/): Dla tech leadów: cotygodniowy dyżur nad wydaniami, ścieżka od pilotażu nowej funkcji do wspólnego harnessu i datowana dokumentacja, którą pilnuje CI.
- [Kolejka code review, gdy pull requesty otwierają agenci](https://developertoolkit.ai/pl/teams/review-queue/): Dla tech leadów: równoważ napływ PR od agentów z przepustowością review — limity WIP, budżet rozmiaru PR, tory ryzyka i obciążenie recenzentów.
- [Jak przekonać sceptyków i seniorów](https://developertoolkit.ai/pl/teams/skeptics-and-seniors/): Sceptycyzm seniorów to lista luk w weryfikacji: niech seniorzy projektują sprawdzenia i prowadzą mierzony pilotaż na własnych zadaniach. Plus uczciwa lektura METR.
- [Jak pomóc zespołowi przestać czytać każdy diff](https://developertoolkit.ai/pl/teams/trust-transfer/): Etapowy protokół transferu zaufania dla każdej pętli: shadow review, review próbkowe, same dowody. Kryteria wejścia, reguły cofania i odpowiedź na obawy.
- [Podnoszenie kompetencji zespołu w inżynierii agentowej](https://developertoolkit.ai/pl/teams/upskilling/): Dla tech leadów i CTO: program na każdy poziom drabiny, katy z własnego repo, sesje review do nauki i rejestr AI literacy pod art. 4.

## Tech Lead Scorecard

- [Scorecard Tech Leada: klucz odpowiedzi](https://developertoolkit.ai/pl/lead-scorecard-guide/): Każde z 25 pytań Scorecardu Tech Leada przypisane do strony, która poprawia odpowiedź, dowód na 3 punkty i czterotygodniowy plan dla jednego zespołu.

## Engineering organization

- [Organizacja inżynierii: agenci kodujący w skali całej firmy](https://developertoolkit.ai/pl/org/): Przewodnik CTO po agentach kodujących w skali firmy: model operacyjny, bramki autonomii, bezpieczeństwo, pomiar, koszty, rekrutacja i zestaw bazowy.
- [Tożsamość agentów, poświadczenia i sekrety](https://developertoolkit.ai/pl/org/agent-identity-and-secrets/): Każdy agent z własną, krótkotrwałą tożsamością o minimalnych uprawnieniach: OIDC w CI, zawężony OAuth dla MCP, sekrety poza kontekstem, utwardzone Actions.
- [Gdy incydent wywoła agent](https://developertoolkit.ai/pl/org/agent-incidents/): Opanuj incydent agenta: unieważnij jego tożsamość, wstrzymaj pętle, ustal pochodzenie zmiany, nazwij zawiedzioną kontrolę i zamień ją w ewaluację.
- [Model zagrożeń dla agentów: prompt injection, dane i zasięg szkód](https://developertoolkit.ai/pl/org/agent-threat-model/): Śmiertelna triada, injection przez issues, PR-y i strony WWW, zakres poświadczeń, eksfiltracja i łańcuch dostaw MCP, skilli i pluginów, zmapowane na OWASP.
- [ISO/IEC 42001, NIST AI RMF i dowody SOC 2 z potoku agentów](https://developertoolkit.ai/pl/org/ai-management-standards/): Mapa kontroli i dowodów: jak pakiet dowodów, bramki, ewaluacje, telemetria i proweniencja odpowiadają audytorom ISO/IEC 42001, NIST AI RMF i SOC 2.
- [Ścieżki kariery i oceny pracy, gdy output jest tani](https://developertoolkit.ai/pl/org/career-ladders/): Przepisz ścieżki kariery wokół efektów, specyfikacji, weryfikacji i harnessu; liczby PR-ów i tokenów trzymaj z dala od ocen, a telemetrię od inwigilacji.
- [Agenci kodujący w sieci korporacyjnej](https://developertoolkit.ai/pl/org/corporate-environment/): Claude Code, Codex i Cursor za proxy korporacyjnym, inspekcją TLS, SSO i listą dozwolonych hostów, wdrożone przez MDM i sprawdzone testem dymnym.
- [Zarządzanie kosztami użycia AI](https://developertoolkit.ai/pl/org/cost-governance/): Zarządzaj wydatkami na Claude Code, Codex i Cursor: telemetria per zespół, limity wydatków, polityka modeli i wysiłku oraz miesięczny przegląd kosztów.
- [Model DORA AI Capabilities: samoocena](https://developertoolkit.ai/pl/org/dora-ai-capabilities/): Oceń organizację w siedmiu zdolnościach modelu DORA AI Capabilities, z dowodem dla każdej oceny i linkiem do strony, która daną zdolność buduje.
- [AI Act dla firm tworzących oprogramowanie z agentami](https://developertoolkit.ai/pl/org/eu-ai-act/): Czego AI Act po Digital Omnibus wymaga od firmy używającej Claude Code, Codex lub Cursora, co zostaje po stronie dostawców i kiedy produkt to zmienia.
- [CRA, NIS2 i DORA-EU: unijne regulacje oprogramowania a zespoły z agentami](https://developertoolkit.ai/pl/org/eu-software-regulation/): Czego Cyber Resilience Act, NIS2, DORA-EU i RODO wymagają od firmy, której kod piszą agenci, i jakie kontrole dostarczają na to dowody.
- [Governance i autonomia: człowiek przy bramkach](https://developertoolkit.ai/pl/org/governance-autonomy/): Autonomia agenta według klasy ryzyka, nie pewności modelu: guardrails w trakcie pracy, bramki przed merge i produkcją, wskazani zatwierdzający.
- [Rekrutacja i rozmowy kwalifikacyjne w inżynierii agentowej](https://developertoolkit.ai/pl/org/hiring/): Rozmowy rekrutacyjne z dozwolonymi agentami: zadania sprawdzające specyfikację, projekt weryfikacji i osąd w code review, oceniane według rubryk z opisanymi poziomami.
- [Prawo i własność intelektualna a kod pisany przez agentów](https://developertoolkit.ai/pl/org/legal-and-ip/): Własność, skażenie licencyjne, zwolnienie z odpowiedzialności (indemnity), warunki danych i klauzule umów z klientami: lista dla prawnika. Stan na 26.09.2026.
- [Jak uniknąć uzależnienia od dostawcy: przenośny kontekst, skille i potoki](https://developertoolkit.ai/pl/org/lock-in-and-portability/): Które zasoby agentów przechodzą między Claude Code, Codeksem i Cursorem, które zostają, i checklista próby wyjścia mierząca realny koszt zmiany dostawcy.
- [Jedna polityka dla wszystkich agentów kodujących](https://developertoolkit.ai/pl/org/managed-policy/): Ustawienia zarządzane w Claude Code, Codeksie, Cursorze i GitHub Copilot: jedna wersjonowana polityka dla modeli, serwerów MCP, pluginów i uprawnień.
- [DORA, SPACE, DX Core 4 i pomiar AI, gdy kod piszą agenci](https://developertoolkit.ai/pl/org/metrics-frameworks/): Które metryki dostarczania przetrwają kod pisany przez agentów, a które się psują, kanoniczne definicje metryk AI i minimalny panel dla każdego poziomu.
- [Gdzie działa model: bramki, chmury, rezydencja danych i zero retencji](https://developertoolkit.ai/pl/org/model-hosting/): API Anthropic, Bedrock, Google Cloud, Foundry, bramka LLM czy własny hosting: gdzie działa inferencja agentów, w jakim regionie zostaje i co obejmuje ZDR.
- [Model operacyjny: kto odpowiada za harness, bramki i ewaluacje](https://developertoolkit.ai/pl/org/operating-model/): RACI dla oprogramowania budowanego przez agentów: właściciele reguł, skilli, hooków, MCP, tożsamości agentów, ewaluacji, pętli i bramki produkcyjnej.
- [Pilotaż, który czegoś dowodzi](https://developertoolkit.ai/pl/org/pilot-design/): Jak zaprojektować 4–8-tygodniowy pilotaż agentów AI: punkt odniesienia z systemów, dobrane kohorty, czynniki zakłócające, liczebność próby i reguła decyzyjna.
- [Zespół platformowy agentów: harness jako produkt](https://developertoolkit.ai/pl/org/platform-team/): Karta, backlog, poziomy usług i metryki produktowe zespołu platformowego, który utrzymuje politykę, skille, hooki, ewaluacje, środowiska i telemetrię agentów.
- [Prywatność danych i polityki firmowe dla agentów kodujących](https://developertoolkit.ai/pl/org/privacy-data-handling/): Ustal, jakie dane mogą trafić do agenta: cztery klasy danych, rejestr zatwierdzonych usług, retencja u dostawców, kontrola kontekstu i testy, które to dowodzą.
- [Zakup narzędzi AI do kodowania: kwestionariusz bezpieczeństwa, prawny i danych](https://developertoolkit.ai/pl/org/procurement/): Kwestionariusz 40 pytań do dostawców narzędzi AI do kodowania (retencja, trening, ZDR, region, SSO/SCIM, audyt, indemnity) i sposób weryfikacji odpowiedzi.
- [Inżynieria agentowa w branżach regulowanych](https://developertoolkit.ai/pl/org/regulated-industries/): Rozdział obowiązków, dowody zarządzania zmianą i ścieżka audytu, gdy agenci piszą i recenzują kod w finansach, ochronie zdrowia i sektorze publicznym.
- [Standardy bezpieczeństwa i zgodność dla agentów kodujących](https://developertoolkit.ai/pl/org/security-compliance/): Bazowy zestaw ośmiu kontroli, z którym Claude Code, Codex i Cursor przechodzą przegląd SOC 2, RODO i HIPAA, oraz testy kontrolne, które to potwierdzają.
- [Polityka korzystania z AI, której inżynierowie będą przestrzegać](https://developertoolkit.ai/pl/org/usage-policy/): Szablon zasad korzystania z agentów AI: klasy danych, zatwierdzone ścieżki, ujawnianie, recenzje i zakazy; przy każdym punkcie sposób egzekwowania.

## Strategy & business

- [Strategia: inżynieria AI-native dla liderów biznesu](https://developertoolkit.ai/pl/strategy/): Decyzje biznesowe inżynierii agentowej: ekonomia, business case, projekt organizacji, tempo zmian i raport dla zarządu, oparte na jasnym standardzie dowodów.
- [Raportowanie inżynierii AI zarządowi i radzie nadzorczej](https://developertoolkit.ai/pl/strategy/board-reporting/): Kwartalny, jednostronicowy raport o inżynierii AI: poziom autonomii każdej krytycznej pętli, koszt zaakceptowanej zmiany, incydenty i rejestr pięciu ryzyk.
- [Oprogramowanie tworzone poza działem inżynierii](https://developertoolkit.ai/pl/strategy/builders-beyond-engineering/): Analitycy i eksperci domenowi budują narzędzia z agentami i kreatorami aplikacji: gdzie to się opłaca, jak prototyp trafia na produkcję i gdzie są granice.
- [Business case dla inżynierii agentowej](https://developertoolkit.ai/pl/strategy/business-case/): Szablon notatki decyzyjnej do finansowania inżynierii agentowej: cztery opcje, punkt odniesienia, pełny koszt, próg rentowności, bramki stopu i ryzyka.
- [Ekonomia oprogramowania budowanego przez agentów: koszt zaakceptowanej zmiany](https://developertoolkit.ai/pl/strategy/economics/): Koszt zaakceptowanej zmiany: licencje, zużycie, CI, review, poprawki i incydenty przez scalone, niecofnięte zmiany. Metoda ROI z przykładem i arkuszem.
- [Jak przeprowadzić ludzi przez zmianę](https://developertoolkit.ai/pl/strategy/leading-the-change/): Co mówić inżynierom i firmie, gdy kod piszą agenci: jednostronicowe stanowisko wobec AI, uczciwe odpowiedzi o etatach i kolejność zmian bez spadku jakości.
- [Jak zmieniają się zespoły, role i zatrudnienie](https://developertoolkit.ai/pl/strategy/org-design/): Projekt organizacji w inżynierii agentowej: zespoły według przepustowości code review, nowe role (harness, ewaluacje, fabryka) i zatrudnienie bez mnożników.
- [Zarządzanie produktem, gdy budowanie trwa godziny](https://developertoolkit.ai/pl/strategy/product-management/): Gdy agenci budują w kilka godzin, product manager pisze intent.md i kryteria akceptacji, prowadzi roadmapę wyników i nie wpuszcza prototypów na produkcję.
- [Software house i agencja w erze agentów](https://developertoolkit.ai/pl/strategy/services-firms/): Wycena, ujawnianie użycia agentów klientom, marża, model zespołów i klauzule umowne o IP, danych i gwarancji dla software house'ów i agencji.
- [Historie sukcesu AI w programowaniu: studia przypadków, które się bronią](https://developertoolkit.ai/pl/strategy/success-stories/): Studia przypadków Stripe, Microsoftu i Anthropic z datowanymi źródłami, kontrdowodami, listą kontrolną do ich weryfikacji i wzorcem do powtórzenia.
- [Mapa drogi dla organizacji: od pilotaży do agentowego systemu dostarczania](https://developertoolkit.ai/pl/strategy/transformation-roadmap/): 12-miesięczny plan przejścia organizacji inżynierskiej od pilotaży AI do agentowego dostarczania, z bramkami stop/go jako przejściami na drabinie autonomii.

## Developer Scorecard

- [Scorecard dewelopera: klucz odpowiedzi](https://developertoolkit.ai/pl/developer-scorecard-guide/): Każde z 25 pytań scorecardu dewelopera przypisane do strony, która poprawia odpowiedź, z dowodem na 3 punkty i kolejnością napraw.
- [Używaj hooków jako deterministycznych guardraili](https://developertoolkit.ai/pl/developer-scorecard-guide/agent-hooks/): Cztery warstwowe hooki dla Claude Code i Codex: chronią ścieżki, blokują ryzykowne komendy, lintują edycje i nie kończą pracy z sekretem w diffie.
- [Agent skills — zamień politykę w testowany workflow](https://developertoolkit.ai/pl/developer-scorecard-guide/agent-skills/): Zamień politykę zespołu w SKILL.md z właścicielem, ładowany przez Claude Code, Codex i Cursor tylko wtedy, gdy trzeba, i sprawdzony testami akceptacyjnymi.
- [Ograniczony agent do triage incydentów](https://developertoolkit.ai/pl/developer-scorecard-guide/ai-on-call-tag/): Agent incydentowy z własną tożsamością tylko do odczytu zbiera dowody i szkicuje oś czasu, a mitygację i przywrócenie działania zatwierdza wskazany człowiek.
- [Uruchom ograniczoną pętlę review-fix dla PR](https://developertoolkit.ai/pl/developer-scorecard-guide/auto-pr-workflow/): Agent triaguje uwagi z review i czerwone CI na PR, naprawia odtworzone przyczyny, ponawia bramki i zatrzymuje się przed akceptacją człowieka. Komendy i prompty.
- [AGENTS.md i CLAUDE.md — zwięzły kontekst repozytorium](https://developertoolkit.ai/pl/developer-scorecard-guide/claude-md-context/): Napisz jeden krótki rdzeń AGENTS.md, podepnij do niego Claude Code, Codex i Cursora i sprawdź /context oraz codex debug prompt-input, co wczytał każdy agent.
- [Ciągłe ewaluacje — testy regresyjne harnessu agenta w CI](https://developertoolkit.ai/pl/developer-scorecard-guide/continuous-evals/): Uruchamiaj w CI prawdziwe zadania przy każdej zmianie CLAUDE.md, AGENTS.md, skilli, hooków, CLI lub modelu, blokuj merge po spadku pass rate, dodawaj incydenty.
- [Deterministyczna detekcja anomalii i ograniczona diagnoza](https://developertoolkit.ai/pl/developer-scorecard-guide/control-band-detection/): Wykrywaj anomalie na produkcji wersjonowanymi regułami alertów testowanymi na odtworzonych danych, a diagnozę każdego alertu zleć agentowi read-only.
- [Subagenci o ograniczonym zakresie — deleguj pracę, nie odpowiedzialność](https://developertoolkit.ai/pl/developer-scorecard-guide/custom-subagents/): Zdefiniuj subagentów explorer i verifier w Claude Code, Codeksie i Cursorze z wymuszonymi limitami narzędzi, stałym formatem wyniku i zmierzonym zyskiem.
- [Weryfikacja w przeglądarce przez agenta — udowodnij flow użytkownika](https://developertoolkit.ai/pl/developer-scorecard-guide/e2e-agent-verification/): Agent sprawdza każde kryterium akceptacji w prawdziwej przeglądarce, zachowuje powtarzalny dowód, a krytyczne flow trafiają do testów Playwright.
- [Uruchamiaj równoległe agenty w izolowanych worktree](https://developertoolkit.ai/pl/developer-scorecard-guide/git-worktrees/): Dwa do czterech zadań agentów naraz w worktree Gita (Claude Code, Codex, Cursor): porty, lokalna konfiguracja, dowód dla strumienia i bezpieczne sprzątanie.
- [Konfiguracja agentów do warstwowego review pull requestów](https://developertoolkit.ai/pl/developer-scorecard-guide/layered-pr-review/): Skonfiguruj agentów review w Claude Code, Codex i Cursorze z jednego REVIEW.md: osobne przejścia, znaleziska z dowodami, bramka w CI i akceptacja człowieka.
- [Routing modeli oparty na dowodach, nie na marce](https://developertoolkit.ai/pl/developer-scorecard-guide/model-routing/): Przypisz każdą klasę pracy agenta do modelu i poziomu rozumowania wybranych przez własne ewaluacje: datowana tabela, konfiguracja narzędzi i test przed i po.
- [Wybierz główny harness do inżynierii z AI](https://developertoolkit.ai/pl/developer-scorecard-guide/primary-ai-tool/): Wybierz Claude Code, Codex albo Cursor jako główny harness na podstawie próby na własnych zadaniach: arkusz ocen, bramki weryfikacji i zapis decyzji.
- [Akceptacja produkcji jako granica systemu](https://developertoolkit.ai/pl/developer-scorecard-guide/production-approval-gate/): Nie pozwól agentom wdrażać niesprawdzonego kodu: osobne tożsamości, brak stałych sekretów produkcji, chronione gałęzie i akceptacja człowieka.
- [Przećwiczony rollback, o którym decyduje człowiek](https://developertoolkit.ai/pl/developer-scorecard-guide/rollback-pipeline/): Rollback jako jedno przećwiczone polecenie: wersjonowany kontrakt, chroniony job, kryteria powrotu do normy i agenci bez dostępu do produkcji.
- [Planowe skany bezpieczeństwa z dowodami i bramką PR](https://developertoolkit.ai/pl/developer-scorecard-guide/scheduled-security-scans/): Co tydzień przypięte skanery i agent tylko do odczytu, wersjonowane dowody, triage po fingerprincie i poprawki wyłącznie przez PR z testem na start.
- [Dobierz plan AI do zmierzonej pracy](https://developertoolkit.ai/pl/developer-scorecard-guide/subscription-plan-fit/): Wybierz najtańszy plan Claude, ChatGPT lub Cursor, który kończy twoją realną pracę agentów: dziennik użycia, kwartalny przegląd i datowana decyzja.
- [Akceptacja wizualna przed implementacją frontendu](https://developertoolkit.ai/pl/developer-scorecard-guide/ui-design-mock/): Zamień intent.md w makietę UI, którą można obejrzeć, zapisz podpisany plik akceptacji wizualnej i sprawdź zbudowany ekran względem niego przed merge.

## CTO Scorecard

- [Scorecard CTO: klucz odpowiedzi](https://developertoolkit.ai/pl/cto-scorecard-guide/): Przedziały poziomów 1–4 w scorecardzie CTO i każde z 25 pytań przypisane do strony, która poprawia odpowiedź, oraz do dowodu na najwyższą ocenę.
- [AI w CI/CD: ograniczona pętla po stronie serwera](https://developertoolkit.ai/pl/cto-scorecard-guide/ai-in-cicd/): Polityka CTO dla agentów w CI/CD: zaufane triggery, job agenta bez zapisu, deterministyczne bramki i człowiek, który merguje. Workflow Claude Code i Codex.
- [Panel metryk AI — mierz zaakceptowane dostarczanie](https://developertoolkit.ai/pl/cto-scorecard-guide/ai-metrics-panel/): Klucz do pytania Q22 CTO Scorecard: ile jest wart każdy wybór, które trzy tworzą działający panel, karta metryki do wdrożenia i weryfikacja liczb.
- [Pochodzenie zmiany i routing ryzyka](https://developertoolkit.ai/pl/cto-scorecard-guide/ai-pr-labeling/): Kieruj każdy pull request według tego, czego dotyka (zapisanego w pakiecie dowodów), a nie według autora. Pochodzenie AI zachowaj do pomiaru i audytu.
- [Roadmapa toolingu AI — szablon pozycji portfela zakładów o nowe zdolności](https://developertoolkit.ai/pl/cto-scorecard-guide/ai-tooling-roadmap/): CTO Scorecard Q24: szablon pozycji portfela dla każdego zakładu o tooling AI na mapie transformacji, z hipotezą, pełnym kosztem, bramką stop i terminem przeglądu.
- [Onboarding developera — udowodnij jeden bezpieczny workflow](https://developertoolkit.ai/pl/cto-scorecard-guide/dev-onboarding-time/): CTO Scorecard Q19: zmierz powtarzalny fixture onboardingu od czystego setupu do zweryfikowanej zmiany próbnej, bez wspólnych sekretów i ukrytej pomocy.
- [Polityka E2E: dowód z przeglądarki dla każdej zmiany widocznej dla użytkownika](https://developertoolkit.ai/pl/cto-scorecard-guide/e2e-policy/): Polityka CTO dla zmian UI robionych przez agentów: dowody z przeglądarki według klasy ryzyka, zachowane trace’y i krytyczne ścieżki w testach Playwright w CI.
- [Wewnętrzne serwery MCP — zbuduj tylko brakujący interfejs](https://developertoolkit.ai/pl/cto-scorecard-guide/internal-mcp-servers/): CTO Scorecard Q7: buduj wewnętrzny serwer MCP tylko dla zmierzonej luki dostępu, z wąskim kontraktem, właścicielem, testami obu er i kryteriami wycofania.
- [Dzielenie się wiedzą — wersjonuj dowody, nie triki](https://developertoolkit.ai/pl/cto-scorecard-guide/knowledge-sharing/): CTO Scorecard Q20: kieruj lekcje z porażek agenta, review i incydentów do jednego wersjonowanego artefaktu z właścicielem i sprawdzaj, czy agent je zna.
- [Bezpieczeństwo MCP — autoryzuj każdą tożsamość i każde narzędzie](https://developertoolkit.ai/pl/cto-scorecard-guide/mcp-security/): CTO Scorecard Q8: allowlista MCP po przeglądzie w konfiguracji zarządzanej, autoryzacja per narzędzie, zatwierdzanie zapisów, logi i testy prompt injection.
- [Polityka planowania: zaakceptowane artefakty przed ryzykownym wykonaniem](https://developertoolkit.ai/pl/cto-scorecard-guide/plan-mode-policy/): Polityka bramki planu (plan gate) dla zmian wrażliwych: najpierw scalone intent, spec i plan, check CI na chronionych ścieżkach i nazwany code owner.
- [ROI toolingu AI — dowody, które dają pełny wynik](https://developertoolkit.ai/pl/cto-scorecard-guide/roi-measurement/): Klucz do pytania Q23 CTO Scorecard: co zawierają dowody ROI z dopasowanych kohort, jak przejść o odpowiedź wyżej i gdzie jest jedyna metoda ROI.
- [Wspólne reguły agentów — jeden rdzeń, przetestowane adaptery](https://developertoolkit.ai/pl/cto-scorecard-guide/shared-agent-rules/): CTO Scorecard Q5: rdzeń w AGENTS.md, cienkie adaptery Claude Code, Codex i Cursora, kontrola w CI i sondy dowodzące, że każdy agent go wczytał.
- [Zarządzanie wspólnymi hookami: kontrole runtime po review](https://developertoolkit.ai/pl/cto-scorecard-guide/shared-hooks-governance/): Zarządzaj wspólnymi hookami agentów jak kodem produkcyjnym: kontrakt, przypięte wersje, przypadki testowe, dystrybucja zarządzana, wdrożenie etapowe i rollback.
- [Wspólne skille: przetestowana wiedza proceduralna](https://developertoolkit.ai/pl/cto-scorecard-guide/shared-skills/): Wspólne skille agentów prowadzone jak kod: kontrakt skilla, jedno źródło dla Claude Code, Codex i Cursora, fixture'y, przypięty marketplace i dowód użycia.
- [Adopcja w zespole — mierz skuteczne użycie workflow](https://developertoolkit.ai/pl/cto-scorecard-guide/team-adoption-rate/): CTO Scorecard Q1: mierz adopcję AI jako uprawnionych inżynierów kończących zatwierdzone workflow, z dowodami wyniku, jakości i kontroli.
- [Konta zespołu — właściciele, cykl życia dostępu i warunki danych](https://developertoolkit.ai/pl/cto-scorecard-guide/team-billing/): CTO Scorecard Q3: przypnij logowanie do narzędzi AI do organizacji, prowadź kontrole joiner/mover/leaver i co miesiąc uzgadniaj licencje i koszty.
- [Równoległa praca agentów w zespole na poziomie 3 — izoluj zadania i ogranicz kolejkę](https://developertoolkit.ai/pl/cto-scorecard-guide/team-parallelism-tier2/): Dla tech leadów i CTO: równoległe zadania agentów jako workflow zespołu na poziomie 3 — izolowany stan, limity per klasa, właściciel integracji, limit kolejki.
- [Polityka automatyzacji review PR w zespole — dowody przed akceptacją](https://developertoolkit.ai/pl/cto-scorecard-guide/team-pr-review-automation/): Polityka organizacji dla review PR przez AI: tory ryzyka, checki rozstrzygające, reguły blokowania, kto akceptuje i metryki opłacalności reviewerów.
- [Polityka prototypów — awans według ryzyka i dowodów](https://developertoolkit.ai/pl/cto-scorecard-guide/team-vibe-coding-policy/): CTO Scorecard Q16: gotowa polityka prototypów z czterema klasami ekspozycji, automatycznymi wyzwalaczami awansu i sześcioma kryteriami przed produkcją.
- [Przebiegi agentów bez nadzoru na poziomie 4–5 — ograniczona praca cykliczna](https://developertoolkit.ai/pl/cto-scorecard-guide/tier3-overnight-runs/): Dla CTO i tech leadów: praca agentów z harmonogramu lub zdarzenia — kontrakt klasy zadań, limit uruchomień, raport z przebiegu i człowiek przy merge.
- [Polityka narzędzi — zatwierdzone workflow i mierzone wyjątki](https://developertoolkit.ai/pl/cto-scorecard-guide/tooling-policy/): CTO Scorecard Q2: macierz zatwierdzonych workflow, datowane karty usług, wymuszone narzędzia domyślne i ograniczone w czasie wyjątki kończące się decyzją.
- [Zarządzanie ryzykiem dostawcy — testuj ciągłość, nie logo](https://developertoolkit.ai/pl/cto-scorecard-guide/vendor-risk-management/): CTO Scorecard Q25: utrzymaj pracę z AI, gdy dostawca zmienia model, limit, trasę lub warunki, dzięki przetestowanemu fallbackowi i ćwiczeniu odtworzenia.

## Reference & help: Reference

- [Dodatki](https://developertoolkit.ai/pl/reference/): Ściągawki do Claude Code, Codexa i Cursora: polecenia, pliki konfiguracji, skróty i pojęcia oraz sprawdzanie ich z wersją, której używasz.
- [Ściągawka poleceń](https://developertoolkit.ai/pl/reference/command-reference/): Polecenia Claude Code, Codex i Cursora porównane z zainstalowanymi CLI: flagi, slash commands, tryb headless, przegląd kodu i przestarzałe flagi do usunięcia.
- [Dokumentacja konfiguracji](https://developertoolkit.ai/pl/reference/config-reference/): Skąd Cursor, Claude Code i Codex czytają instrukcje projektu: .cursor/rules, CLAUDE.md, AGENTS.md i config.toml, z regułami ładowania i testami.
- [Hasła od A do Z: pojęcia programowania z AI](https://developertoolkit.ai/pl/reference/glossary/): Hasła od A do Z o programowaniu z AI: znaczenie, nazwa w Claude Code, Codeksie i Cursorze oraz różnice między 21 nazwami pracy z AI.
- [Skróty klawiszowe w Claude Code, Codeksie i Cursorze](https://developertoolkit.ai/pl/reference/keyboard-shortcuts/): Klawisze, które zatrzymują, cofają, planują i pokazują pracę agenta w Claude Code 2.1.283, Codex CLI 0.157.1 i Cursorze, ich zmiana i pułapki tmux.

## Reference & help: Help & updates

- [Dodatkowe zasoby](https://developertoolkit.ai/pl/resources/): Co zrobić, gdy Claude Code, Codex lub Cursor przestaje działać albo się zmienia: triaż, polecenia doctor oraz FAQ, rozwiązywanie problemów i changelog.
- [Zasoby społeczności](https://developertoolkit.ai/pl/resources/community/): Gdzie odpowiadają opiekunowie Cursora, Claude Code i Codeksa, skąd brać skille, wtyczki, serwery MCP i jak sprawdzić poprawkę ze społeczności przed wdrożeniem.
- [Najczęściej zadawane pytania](https://developertoolkit.ai/pl/resources/faq/): Krótkie, sprawdzone odpowiedzi o Claude Code, Codex i Cursorze: domyślne modele, ceny planów, prywatność, uprawnienia, review, MCP, skille i limity.
- [Prześlij opinię](https://developertoolkit.ai/pl/resources/feedback/): Zgłaszaj błędy Claude Code, Codex i Cursora tak, by dało się je odtworzyć, kieruj prośby o funkcje i luki bezpieczeństwa oraz zgłaszaj błędy w tym przewodniku.
- [Rozwiązywanie problemów z Claude Code, Codex i Cursorem](https://developertoolkit.ai/pl/resources/troubleshooting/): Ustal, która warstwa zawiodła w Claude Code, Codex lub Cursorze: instalacja, logowanie, limity, reguły, kontekst, MCP, utracona praca. Potem udowodnij poprawkę.
- [Co nowego w AI Developer Toolkit](https://developertoolkit.ai/pl/resources/whats-new/): Zmiany w Claude Code, Codeksie i Cursorze wpływające na konfigurację agentów na 12 października 2026, z poprawką dla każdej, oraz przewodniki serwisu miesiąc po miesiącu.

## Darmowe strony (bez konta)

- [Porównanie narzędzi AI do kodowania](https://developertoolkit.ai/pl/compare/): Cursor, Claude Code i Codex obok siebie: interfejs, agenci, modele, bezpieczeństwo i cena, z jasnym werdyktem dla każdej pary i linkami do dokumentacji.
- [Cursor vs Claude Code vs Codex](https://developertoolkit.ai/pl/compare/best-ai-coding-tools/): Cursor, Claude Code i Codex porównane: interfejs, agenci, bezpieczeństwo, ceny z datą tam, gdzie je podaje dokumentacja, i odpowiedź, od którego zacząć.
- [Cursor vs Claude Code](https://developertoolkit.ai/pl/compare/cursor-vs-claude-code/): Cursor i Claude Code porównane pod kątem interfejsu, możliwości agenta i przebiegów bez nadzoru. Tabela, jasny werdykt i argument za używaniem obu.
- [Claude Code vs Codex](https://developertoolkit.ai/pl/compare/claude-code-vs-codex/): Claude Code i OpenAI Codex pod kątem powierzchni, modeli, trybów zatwierdzania i ceny: 33 zdarzenia hooków wobec 12 i skąd każde bierze zadania.
- [Cursor vs Codex](https://developertoolkit.ai/pl/compare/cursor-vs-codex/): Cursor i OpenAI Codex pod kątem interfejsu, integracji i pracy bez nadzoru: jedno wnosi AI do edytora, drugie agenta do GitHuba, Slacka i chmury.
- [Cursor vs GitHub Copilot](https://developertoolkit.ai/pl/compare/cursor-vs-github-copilot/): Cursor i GitHub Copilot porównane: cloud agent Copilota startuje ze zgłoszenia na GitHubie, agent Cursora w edytorze na bazie VS Code. Gdzie który pasuje.
- [Słownik AI: inżynieria agentowa a vibe coding](https://developertoolkit.ai/pl/glossary/): Trzydzieści cztery hasła o agentach kodujących AI: inżynieria agentowa wobec vibe codingu i pojęcia narzędzi, od MCP po tryb planowania, każde z definicją.
- [Czym są Agent Skills?](https://developertoolkit.ai/pl/glossary/agent-skills/): Agent Skills to przenośny, otwarty standard rozszerzania agentów AI. Jak się je instaluje, którzy agenci je obsługują i czym różnią się od serwerów MCP.
- [Czym jest inżynieria agentowa?](https://developertoolkit.ai/pl/glossary/agentic-engineering/): Inżynieria agentowa to nazwa, którą w lutym 2026 spopularyzował Andrej Karpathy dla koordynowania omylnych, ale mocnych agentów bez obniżania jakości.
- [Czym jest AGENTS.md?](https://developertoolkit.ai/pl/glossary/agents-md/): AGENTS.md to plik repozytorium, z którego Codex uczy się, jak mają działać agenci. Gdzie go umieścić, co w nim zapisać i czym różni się od CLAUDE.md.
- [Czym jest CLAUDE.md?](https://developertoolkit.ai/pl/glossary/claude-md/): CLAUDE.md to plik, który Claude Code czyta automatycznie jako kontekst projektu. Gdzie go umieścić, co w nim zapisać i jak ma się do AGENTS.md.
- [Czym jest okno kontekstu?](https://developertoolkit.ai/pl/glossary/context-window/): Okno kontekstu to tekst, który model trzyma naraz. Co je zapełnia, jaki ma rozmiar w Claude Code i Codeksie i kiedy kompaktować, czyścić albo delegować.
- [Czym są Git worktrees?](https://developertoolkit.ai/pl/glossary/git-worktrees/): Git worktrees dają kilka branchy naraz, każdy w osobnym katalogu. Dlaczego potrzebują ich równolegli agenci AI i jak używa ich Codex do izolowanych zadań.
- [Czym jest tryb headless?](https://developertoolkit.ai/pl/glossary/headless-mode/): Tryb headless uruchamia agenta AI bez człowieka w pętli, do CI i automatyzacji. Polecenia w Claude Code i Codeksie oraz co zabezpieczyć przed jego użyciem.
- [Czym są hooki?](https://developertoolkit.ai/pl/glossary/hooks/): Hooki uruchamiają się przed lub po wywołaniach narzędzi agenta (.claude/settings.json). Do czego służą i dlaczego biją proszenie agenta o dobre zachowanie.
- [Czym jest MCP (Model Context Protocol)?](https://developertoolkit.ai/pl/glossary/mcp/): MCP to otwarty standard łączenia agentów kodujących z zewnętrznymi narzędziami i danymi na żywo. Jak dodają serwer MCP Claude Code, Codex i Cursor.
- [Czym jest tryb planowania?](https://developertoolkit.ai/pl/glossary/plan-mode/): Tryb planowania każe agentowi AI przygotować plan, zanim cokolwiek zmieni. Jak wejść w niego w Claude Code i jak tę samą fazę udostępniają Cursor i Codex.
- [Czym jest sandbox?](https://developertoolkit.ai/pl/glossary/sandbox/): Sandbox ogranicza to, czego mogą dotknąć polecenia agenta AI. Czym różni się od zatwierdzania i jak wdrażają go Claude Code, Codex i Cursor.
- [Czym są komendy slash?](https://developertoolkit.ai/pl/glossary/slash-commands/): Komendy slash uruchamiają wbudowane i własne akcje w agentach AI. Które ma Claude Code, które Codex i dlaczego jedynym pewnym spisem jest wpisanie znaku /.
- [Czym jest fabryka oprogramowania?](https://developertoolkit.ai/pl/glossary/software-factory/): Fabryka oprogramowania: agenci biorą zadania z kolejki, a bramki weryfikacji decydują, co się scala. Poziom 5 drabiny autonomii.
- [Czym jest subagent?](https://developertoolkit.ai/pl/glossary/subagents/): Subagent to instancja AI uruchamiana do jednego podzadania we własnym oknie kontekstu. Jak działa w Cursorze, Claude Code i Codex oraz kiedy się opłaca.
- [Czym jest orkiestracja agentów?](https://developertoolkit.ai/pl/glossary/agent-orchestration/): Orkiestracja agentów: koordynowanie kilku agentów kodujących przy jednym zadaniu. Wzorzec Anthropic, Gas Town i związek z vibe codingiem.
- [Czym jest kodowanie agentowe?](https://developertoolkit.ai/pl/glossary/agentic-coding/): Kodowanie agentowe: agent AI planuje, pisze, uruchamia i testuje kod w pętli. Czym różni się od vibe codingu i inżynierii agentowej, z datowanymi źródłami.
- [Czym jest agentowe tworzenie oprogramowania?](https://developertoolkit.ai/pl/glossary/agentic-software-development/): Agentowe tworzenie oprogramowania: agenci w całym cyklu życia, ludzie odpowiedzialni na bramkach. Kto użył nazwy i czym różni się ona od vibe codingu.
- [Czym są agentowe przepływy pracy?](https://developertoolkit.ai/pl/glossary/agentic-workflows/): Agentowe przepływy pracy (agentic workflows): model pracuje w kilku przebiegach. Spopularyzował je Andrew Ng w 2024. Różnica wobec agentów i vibe codingu.
- [Czym są agenci kodujący AI?](https://developertoolkit.ai/pl/glossary/ai-coding-agents/): Agenci kodujący AI czytają kod, edytują pliki, uruchamiają polecenia i sprawdzają wyniki w pętli. Czym różnią się Claude Code, Codex i Cursor, z datami.
- [Czym jest inżynieria AI?](https://developertoolkit.ai/pl/glossary/ai-engineering/): Inżynieria AI to budowanie aplikacji na modelach bazowych, rola spopularyzowana przez swyx w 2023. Czym różni się od inżynierii agentowej i vibe codingu.
- [Czym jest programowanie w parze z AI?](https://developertoolkit.ai/pl/glossary/ai-pair-programming/): Programowanie w parze z AI to praca obok asystenta kodowania z czytaniem każdej sugestii; wyrażenie spopularyzował GitHub Copilot w 2021.
- [Czym jest AI SDLC? Inaczej agentic SDLC](https://developertoolkit.ai/pl/glossary/ai-sdlc/): AI SDLC (agentic SDLC): cykl życia, w którym agenci robią pierwszy przebieg etapów, a wskazane osoby odpowiadają za bramki. Różnica wobec vibe codingu.
- [Czym jest kodowanie wspomagane AI?](https://developertoolkit.ai/pl/glossary/ai-assisted-coding/): Kodowanie wspomagane AI to nadrzędne pojęcie dla użycia LLM i agentów przy pisaniu oprogramowania. Gdzie leżą w nim vibe coding i inżynieria agentowa.
- [Czym jest AI-DLC? Metodyka AWS](https://developertoolkit.ai/pl/glossary/ai-dlc/): AI-DLC to metodyka AWS (AI-Driven Development Lifecycle): bolts, Mob Elaboration, Mob Construction. Otwarta w 2025. Różnica wobec vibe codingu.
- [Czym jest programowanie sterowane przez AI?](https://developertoolkit.ai/pl/glossary/ai-driven-development/): Programowanie sterowane przez AI: ogólne określenie pracy prowadzonej przez AI, bez właściciela. Trzy podejścia AWS i różnica wobec vibe codingu.
- [Czym jest programowanie AI-native?](https://developertoolkit.ai/pl/glossary/ai-native-development/): Programowanie AI-native to model pracy zespołu zbudowany wokół AI, a nie dodany do starego procesu. Kto wprowadził termin i czym różni się od vibe codingu.
- [Czym jest kodowanie rozszerzone?](https://developertoolkit.ai/pl/glossary/augmented-coding/): Kodowanie rozszerzone (augmented coding) to nazwa Kenta Becka z 2025 dla pracy z AI, w której nadal dbasz o kod i testy. Czym różni się od vibe codingu.
- [Czym jest compound engineering? Metoda Every](https://developertoolkit.ai/pl/glossary/compound-engineering/): Compound engineering to metoda Every, w której każda zmiana lepiej przygotowuje agenta kodującego na następną: kto ją ukuł, pętla i vibe coding.
- [Czym jest inżynieria kontekstu?](https://developertoolkit.ai/pl/glossary/context-engineering/): Inżynieria kontekstu to decydowanie, co agent kodujący widzi w każdym kroku: kto ją nazwał, czym różni się od inżynierii promptów i od vibe codingu.
- [Czym jest inżynieria harnessu?](https://developertoolkit.ai/pl/glossary/harness-engineering/): Inżynieria harnessu zamienia powtarzające się błędy agenta w stałe kontrole. Kto ją nazwał i czym różni się od inżynierii kontekstu oraz vibe codingu.
- [Czym jest inżynieria promptów?](https://developertoolkit.ai/pl/glossary/prompt-engineering/): Inżynieria promptów: pisanie i dopracowywanie instrukcji dla modelu AI. Czemu uwagę przejęła inżynieria kontekstu i czym różni się od vibe codingu.
- [Czym jest programowanie sterowane specyfikacją?](https://developertoolkit.ai/pl/glossary/spec-driven-development/): Programowanie sterowane specyfikacją: agent buduje według sprawdzonej specyfikacji. Kto użył nazwy pierwszy, trzy poziomy i różnica wobec vibe codingu.
- [Czym jest vibe coding?](https://developertoolkit.ai/pl/glossary/vibe-coding/): Vibe coding to przyjmowanie kodu napisanego przez AI bez czytania; termin ukuł Andrej Karpathy 2 lutego 2025. Czym różni się od inżynierii agentowej.
- [Czym jest vibe engineering?](https://developertoolkit.ai/pl/glossary/vibe-engineering/): Vibe engineering to nazwa Simona Willisona z października 2025 dla odpowiedzialnej pracy z AI. Czym różni się od vibe codingu i inżynierii agentowej.
- [Kodowanie z AI według roli](https://developertoolkit.ai/pl/for/): Co agent AI zmienia dla backendu, frontendu, mobile, DevOps, solo builderów, tech leadów i CTO, a do tego darmowy scorecard dla każdej z tych ról.
- [Narzędzia AI do kodowania dla programistów backendu](https://developertoolkit.ai/pl/for/backend-developers/): Jak agenci AI zmieniają pracę na backendzie: wzorce API i baz danych oraz receptury dla Node, Pythona, Go, Rusta, Javy, PHP, Elixira i serverless.
- [Narzędzia AI do kodowania dla programistów frontendu](https://developertoolkit.ai/pl/for/frontend-developers/): Jak agenci AI wpasowują się w pracę na froncie, receptury dla Reacta, Vue, Angulara, Next.js i Nuxta oraz narzędzie, które pasuje do edycji wizualnej.
- [Narzędzia AI do kodowania dla programistów mobilnych](https://developertoolkit.ai/pl/for/mobile-developers/): Jak agenci AI wpasowują się w mobile, z recepturami dla React Native, Expo i Fluttera, i gdzie pętla budowania zmienia to, co agent może zweryfikować.
- [Narzędzia AI dla inżynierów DevOps i platformy](https://developertoolkit.ai/pl/for/devops-engineers/): Jak bezpiecznie uruchamiać agentów AI w CI: dokładna lista dozwolonych poleceń, sandbox, tryb headless — plus receptury dla Dockera, Kubernetesa i IaC.
- [Narzędzia AI do kodowania dla solo builderów](https://developertoolkit.ai/pl/for/solo-builders/): Wysyłanie kodu w pojedynkę z agentami AI: bez recenzenta zabezpieczenia muszą być strukturalne. Co ustawić najpierw i od którego narzędzia zacząć.
- [Narzędzia AI do kodowania dla tech leadów](https://developertoolkit.ai/pl/for/engineering-leads/): Wdrożenie agentów AI w zespole: wspólne standardy, przegląd, który się skaluje, i rachunek za miejsca. Co się zmienia, gdy każdy prowadzi agenta.
- [Narzędzia AI do kodowania dla CTO i założycieli](https://developertoolkit.ai/pl/for/ctos/): Wdrożenie agentów AI w organizacji: governance, widoczność kosztów, bezpieczeństwo i liczby, o które warto pytać zamiast obietnicy produktywności.

## Języki

- Polski: https://developertoolkit.ai/pl/
- Angielski: https://developertoolkit.ai/en/
- Indeks angielski (llms.txt): https://developertoolkit.ai/llms.txt

## Pełna dokumentacja dla systemów AI

- [Serwer MCP](https://developertoolkit.ai/mcp): punkt końcowy Model Context Protocol (Streamable HTTP, bez autoryzacji). Narzędzia: `search` po 1100+ artykułach, `fetch` dla pełnego markdownu artykułu.
- [Wszystkie polskie przewodniki w jednym pliku](https://developertoolkit.ai/llms-full-pl.txt): 14.1 MB — przy ograniczonym oknie kontekstu użyj plików sekcji poniżej
- [Wszystkie angielskie przewodniki w jednym pliku](https://developertoolkit.ai/llms-full.txt)
- [Autonomy Ladder (free, no account required) (plik sekcji PL)](https://developertoolkit.ai/llms/pl/ladder.txt)
- [Start here (free, no account required) (plik sekcji PL)](https://developertoolkit.ai/llms/pl/start.txt)
- [Cursor (plik sekcji PL)](https://developertoolkit.ai/llms/pl/cursor-ide.txt)
- [Claude Code (plik sekcji PL)](https://developertoolkit.ai/llms/pl/claude-code.txt)
- [Codex (plik sekcji PL)](https://developertoolkit.ai/llms/pl/codex.txt)
- [Workflows & method: Method (plik sekcji PL)](https://developertoolkit.ai/llms/pl/method.txt)
- [Workflows & method: Workflows, all tools (plik sekcji PL)](https://developertoolkit.ai/llms/pl/workflows.txt)
- [Ecosystem & comparisons: Choose a tool (plik sekcji PL)](https://developertoolkit.ai/llms/pl/comparison.txt)
- [Ecosystem & comparisons: Models, MCP, skills and agent tools (plik sekcji PL)](https://developertoolkit.ai/llms/pl/ecosystem.txt)
- [Cookbook (plik sekcji PL)](https://developertoolkit.ai/llms/pl/cookbook.txt)
- [Lead a team (plik sekcji PL)](https://developertoolkit.ai/llms/pl/teams.txt)
- [Tech Lead Scorecard (plik sekcji PL)](https://developertoolkit.ai/llms/pl/lead-scorecard-guide.txt)
- [Engineering organization (plik sekcji PL)](https://developertoolkit.ai/llms/pl/org.txt)
- [Strategy & business (plik sekcji PL)](https://developertoolkit.ai/llms/pl/strategy.txt)
- [Developer Scorecard (plik sekcji PL)](https://developertoolkit.ai/llms/pl/developer-scorecard-guide.txt)
- [CTO Scorecard (plik sekcji PL)](https://developertoolkit.ai/llms/pl/cto-scorecard-guide.txt)
- [Reference & help: Reference (plik sekcji PL)](https://developertoolkit.ai/llms/pl/reference.txt)
- [Reference & help: Help & updates (plik sekcji PL)](https://developertoolkit.ai/llms/pl/resources.txt)

## Opcjonalne

- [Porównanie narzędzi AI do kodowania](https://developertoolkit.ai/pl/compare/)
- [Cennik w PLN (maszynowo czytelny)](https://developertoolkit.ai/pricing-pl.md)
- [Cennik w USD (maszynowo czytelny)](https://developertoolkit.ai/pricing.md)
- [Mapa strony](https://developertoolkit.ai/sitemap-index.xml)