# Everything Claude Code: największy pakiet w praktyce

URL: https://developertoolkit.ai/pl/ecosystem/frameworks/everything-claude-code/
Description: 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.

Everything Claude Code (ECC, repozytorium `affaan-m/ECC`) to otwartoźródłowy pakiet harnessu dla agentów kodujących i największa zmierzona wtyczka: 68 subagentów, 386 skilli i poleceń, siedem zdarzeń hooków oraz wpis serwera MCP Chrome DevTools. Najlepiej działa w Claude Code, instaluje się też w Codeksie i Cursorze i dodaje około 41 500 stałych tokenów do każdej sesji Claude Code.

Zobaczyłeś liczbę gwiazdek, wpisałeś dwa polecenia instalacji i teraz twój agent ma więcej poleceń z ukośnikiem, niż twój zespół ma konwencji. Odczyt `/context` skoczył, hook Stop uruchamia sprawdzanie typów, o które nikt nie prosił, i nikt nie potrafi powiedzieć, który z 386 wpisów robi coś pożytecznego. Ta strona jest dla programisty, który chce użyć najlepszych części ECC na prawdziwej funkcji, bez dźwigania reszty.

**Wersje na tej stronie**

Sprawdzone 2026-09-26. Liczby dla Claude Code pochodzą z `claude plugin details ecc@ecc` (Claude Code 2.1.283, wtyczka 2.2.2). README ECC podaje wydanie 2.2.2 (2026-08-31); w npm `ecc-universal` jest w wersji **2.2.1**, a `ecc-universal@2.2.2` zwraca E404 (`npm view`, 2026-09-26). Popularność: 268 tys. gwiazdek i 40 tys. forków na [affaan-m/ECC](https://github.com/affaan-m/ECC), odczyt ze strony repozytorium z 2026-09-26. Gwiazdki mierzą zainteresowanie, nie użycie.

## Co zyskujesz, przeprowadzając jedną funkcję przez ECC

- Polecenie instalacji dla Claude Code, Codeksa i Cursora oraz jeden błąd na narzędzie, który wszystko podwaja.
- Inwentarz tego, co wtyczka naprawdę wkłada do sesji, ze zmierzonym kosztem kontekstu obok lżejszych frameworków.
- Przebieg na jednej funkcji (limit prób logowania): plan, budowa zaczynająca się od testów, recenzja w świeżym kontekście, przegląd bezpieczeństwa, zapis sesji.
- Tabelę „zostaw i wytnij” oraz odchudzoną instalację z dziesięcioma komponentami zamiast 454 skilli i agentów.
- Pułapki: kolizje nazw poleceń, przypięta wersja, która się nie rozwiązuje, porady kosztowe sprzeczne z domyślnymi ustawieniami narzędzia i repozytoria-podróbki.

## Co instaluje Everything Claude Code?

ECC opisuje się jako pętla: plan, test, implementacja, recenzja, weryfikacja, zapamiętanie, poprawa. Dostarcza tę pętlę jako pięć rodzajów komponentów. README i Claude Code liczą je inaczej, więc tabela pokazuje oba źródła.

| Komponent | Liczba w README (2.2.2) | Co raportuje `claude plugin details` | Co robi w twojej sesji |
| --- | --- | --- | --- |
| Subagenci | 68 agentów | 68 agentów | Wyspecjalizowani wykonawcy, np. `planner`, `tdd-guide`, `code-reviewer`, `security-reviewer`, `build-error-resolver`, `e2e-runner` i recenzenci dla poszczególnych języków |
| Skille | 292 skille | 386 skilli (czyli 292 skille plus 94 polecenia) | Procesy, np. `tdd-workflow`, `security-review`, `verification-loop`, `search-first`, `e2e-testing`, `strategic-compact`, `context-budget` |
| Polecenia | 94 polecenia | liczone jako skille | Punkty wejścia, np. `/ecc:plan`, `/ecc:code-review`, `/ecc:build-fix`, `/ecc:save-session` |
| Hooki | „Runtime” | 7 zdarzeń hooków | `SessionStart`, `PreToolUse`, `PostToolUse`, `PostToolUseFailure`, `PreCompact`, `Stop`, `SessionEnd`; samo `Stop` ma siedem identyfikatorów hooków, w tym `stop:format-typecheck` i `stop:check-console-log` w profilach `standard` i `strict` |
| MCP | jeden domyślny konektor | 1 (`chrome-devtools`) | Debugowanie w przeglądarce; README mówi, że instalacja wtyczki nie włącza automatycznie definicji MCP z ECC, więc sprawdź `/mcp` |
| Reguły | „Selektywnie” | poza wtyczką | Zawsze ładowane standardy (`rules/common` plus pakiety językowe), które kopiujesz ręcznie, bo wtyczki Claude Code nie mogą dystrybuować reguł |

Przed instalacją liczą się dwie konsekwencje. Po pierwsze, ECC jest [wtyczką](/pl/ecosystem/plugins/), więc instaluje się w całości; gdy chcesz wybierać komponenty, README odsyła do własnego instalatora, nie do wtyczki. Po drugie, hooki to kod uruchamiany poza pytaniem o uprawnienia, więc traktuj środowisko uruchomieniowe hooków jak coś, co recenzujesz, tak jak opisuje to strona o [automatyzacji hookami](/pl/claude-code/automate/hooks-automation/).

## Ile ECC kosztuje w kontekście?

Najważniejsza liczba o ECC to nie liczba gwiazdek. Claude Code 2.1.283 szacuje dla `ecc@ecc` około **41 515 stałych tokenów**: opisy skilli i agentów, które jadą z każdą sesją. To jeszcze przed kontekstem dokładanym przez hook `SessionStart`, który ECC domyślnie ogranicza do 8000 znaków (`ECC_SESSION_START_MAX_CHARS`).

| Wtyczka (Claude Code 2.1.283, 2026-09-26) | Skille | Agenci | Stałe tokeny |
| --- | ---: | ---: | ---: |
| `superpowers@claude-plugins-official` | 15 | 0 | ~838 |
| `mattpocock-skills@claude-plugins-official` | 25 | 0 | ~1 609 |
| `agent-skills@addy-agent-skills` | 34 | 4 | ~3 620 |
| `gsd-core@gsd-core` | 144 | 64 | ~10 700 |
| `ecc@ecc` | 386 | 68 | **~41 515** |

Źródło: pomiar poleceniem `claude plugin details <wtyczka>` w Claude Code 2.1.283, 2026-09-26. To projekcje samego Claude Code, nie dane rozliczeniowe.

Na Claude Opus 5.5, domyślnym modelu Claude Code od v2.1.280 na obu kanałach wydań, z oknem 1M tokenów (zobacz [przegląd modeli](/pl/ecosystem/models/)), 41 500 tokenów to około 4% okna. Okno nie jest jednak prawdziwym kosztem. Te tokeny są rozliczane jako wejście przy każdym żądaniu, a kilkaset podobnych opisów skilli daje modelowi więcej okazji, żeby wybrać zły. Strona o [koszcie kontekstu](/pl/workflows/context/cost-per-context/) pokazuje, jak przeliczyć liczbę tokenów na pieniądze dla twojego ruchu.

Zmierz to u siebie przed instalacją i po niej, w terminalu i w sesji:

```bash
claude plugin details ecc@ecc   # terminal: always-on tokens, skills, agents, hooks, MCP
```

```text
/context
```

Uruchom `/context` w świeżej sesji bez ECC, potem z ECC, i zapisz obie liczby w pull requeście, który dodaje ECC do konfiguracji zespołu.

## Zainstaluj ECC w Claude Code, Codeksie albo Cursorze

README ECC mówi to samo dla każdego narzędzia: wybierz jedną metodę instalacji na narzędzie i nigdy nie nakładaj dwóch. Wtyczka plus instalacja ręczna dublują skille, polecenia i hooki, a zdublowane hooki uruchamiają się dwa razy.

**Claude Code**

W sesji Claude Code (wymaga Claude Code 2.1 lub nowszego, Gita i Node.js 18 lub nowszego):

```text
/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc
```

Potem otwórz nową sesję, uruchom `/plugin list` i sprawdź, czy `ecc@ecc` jest włączona. W terminalu to samo pokaże `claude plugin list`.

W naszej instalacji z 2026-09-26 pojawił się komunikat „2 userConfig options not yet set”. Uruchom `/ecc:configure-ecc`, żeby je ustawić i wybrać profil hooków; profil domyślny (`ECC_HOOK_PROFILE`) to `standard`.

Reguły nie przychodzą z wtyczką. Skopiuj pakiet wspólny i jeden pakiet językowy tylko do tego repozytorium (zakres projektu trzyma je z dala od innych projektów):

```bash
git clone https://github.com/affaan-m/ECC.git ~/src/ECC
mkdir -p .claude/rules/ecc
cp -R ~/src/ECC/rules/common .claude/rules/ecc/
cp -R ~/src/ECC/rules/typescript .claude/rules/ecc/   # your stack, not all of them
```

**Codex**

W terminalu (codex-cli 0.157.1 ma `codex plugin marketplace add` i `codex plugin add`; czasownik to `add`, nie `install`):

```bash
codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json
```

`codex plugin list --json` potwierdza, że wtyczka jest zarejestrowana. Zrestartuj Codeksa i uruchom `$configure-ecc`: sprawdza, czy wtyczka się ładuje, i prowadzi przez konfigurację.

Codex trzyma jeden stan włączonych wtyczek na `CODEX_HOME`, bez zakresów user, project i local, a jego hooki wymagają jawnej decyzji o zaufaniu; cztery profile hooków ECC dla Claude nie mają tu zastosowania. Nie uruchamiaj dodatkowo starszej ścieżki `scripts/sync-ecc-to-codex.sh`, którą README oznacza jako przestarzałą.

Codex 0.157.1 nie ma odpowiednika `claude plugin details`, więc liczba powyżej dotyczy tylko Claude Code.

**Cursor**

Cursor nie ma wtyczki ECC. README instaluje adapter lokalny dla projektu z klonu, w repozytorium, które chcesz wyposażyć:

```bash
git clone https://github.com/affaan-m/ECC.git ~/src/ECC
cd ~/src/ECC
./install.sh --profile minimal --target cursor
```

Adapter zapisuje pliki w `.cursor/`, definicje agentów w `.cursor/agents/ecc-*.md`, i nie instaluje głównego `AGENTS.md`. README ostrzega, że natywne ładowanie w Cursorze „can vary by Cursor build”. Nie uruchamialiśmy tej ścieżki; pochodzi z README.

**Pułapki przy instalacji ECC**

- **Tylko oficjalne źródła.** README wymienia dokładnie: repozytorium `affaan-m/ECC`, pakiety npm `ecc-universal` i `ecc-agentshield`, identyfikator wtyczki `ecc@ecc`, aplikację GitHub `ecc-tools` i `ecc.tools`. Ostrzega, że kopie z innych źródeł „may contain malware”. Repozytorium zmieniło nazwę z `everything-claude-code`; `github.com/affaan-m/everything-claude-code` nadal otwiera `affaan-m/ECC` (sprawdzone 2026-09-26).
- **Przypięta wersja z README się nie rozwiązuje.** `npx ecc-universal@2.2.2 setup` kończy się błędem E404, bo najnowsza wersja w npm to 2.2.1 (sprawdzone 2026-09-26). Użyj poleceń wtyczki powyżej albo przypnij `@2.2.1` po przejrzeniu tego wydania.
- **`ecc-install` to nie pakiet.** To binarka wewnątrz `ecc-universal`; `npx ecc-install` kończy się błędem: w npm nie ma pakietu o tej nazwie (E404, 2026-09-26). Jeśli taki pakiet pojawi się później, to nie jest ECC.
- **Nie wklejaj `hooks/hooks.json` do `settings.json`** po instalacji wtyczki. Claude Code 2.1+ ładuje hooki wtyczek automatycznie, więc kopia uruchamia je dwa razy.
- **`/multi-plan`, `/multi-execute` i pozostałe polecenia `multi-*` wymagają osobnego środowiska uruchomieniowego** (`ccg-workflow`), którego ECC nie dołącza. Bez niego nie działają.

## Zbuduj jedną funkcję z ECC: limit prób logowania

Funkcja: serwis w Express i TypeScripcie, w którym `POST /api/auth/login` ma zwrócić `429` z nagłówkiem `Retry-After` po pięciu nieudanych próbach dla jednego konta w ciągu 15 minut, a poprawne hasło nadal zeruje licznik. Jest na tyle mała, że mieści się w jednej sesji, i na tyle wrażliwa, że wymaga recenzji. Polecenia są w formie wtyczki Claude Code; README przypisuje każdemu subagenta, którego używa. W Codeksie te same skille wywołujesz przez `$` (np. `$tdd-workflow`, tak jak README robi z `$configure-ecc`); w Cursorze adapter instaluje agentów jako `.cursor/agents/ecc-*.md`, do których odwołujesz się po nazwie.

1. **Zaplanuj przez `/ecc:plan`.** Subagent `planner` pisze plan implementacji. Sprawdź w nim trzy rzeczy: gdzie jest przechowywany licznik (w pamięci psuje się przy więcej niż jednej instancji), czym jest klucz (konto, IP czy oba) i które testy dowodzą zachowania.

   **Prompt do skopiowania: plan limitu prób**

   ```text
   /ecc:plan "Add per-account rate limiting to POST /api/auth/login. After 5 failed attempts for the same account within 15 minutes, respond 429 with a Retry-After header in seconds. A successful login resets the counter. Store counters in the existing Redis client (src/lib/redis.ts), not in memory. List the acceptance tests first, then the files you will touch. Do not write code yet."
   ```

2. **Buduj od testów przez `tdd-workflow`.** Uruchom skill `tdd-workflow` (albo wywołaj subagenta `tdd-guide` po nazwie): interfejsy, padające testy (red), minimalny kod (green), refaktoryzacja. Szukaj w transkrypcie czerwonego przebiegu testów przed jakąkolwiek implementacją. Test, który nigdy nie padł, niczego nie dowodzi. Własny próg skilla to 80% pokrycia; jeśli twoje CI ma inny, wygrywa CI.

   **Prompt do skopiowania: implementacja w TDD**

   ```text
   Use the tdd-workflow skill to implement the approved plan. Start with these failing tests in tests/auth/login-rate-limit.test.ts: (1) the 6th failed attempt within 15 minutes returns 429 with a numeric Retry-After, (2) attempts for a different account are unaffected, (3) a correct password after 3 failures resets the count, (4) the window expires after 15 minutes using fake timers. Run the tests and show me the red output before you write any implementation. Then make them pass with the smallest change and run the full test suite.
   ```

3. **Zrecenzuj w świeżym kontekście przez `/ecc:code-review`.** Subagent `code-reviewer` czyta diff bez rozmowy o implementacji w swoim kontekście. Wpisz formę z przestrzenią nazw: samo `/code-review` uruchamia wbudowany skill recenzji Claude Code.

4. **Zrób przegląd bezpieczeństwa przez `ecc:security-review`.** Limit prób to mechanizm uwierzytelniania, więc proś o ataki, nie o recenzję stylu. Podaj skill z przestrzenią nazw: samo `/security-review` uruchamia wbudowany w Claude Code przegląd zmian oczekujących na gałęzi, a nie listę kontrolną ECC. Jeśli wolisz oddać ten przegląd subagentowi `security-reviewer`, poproś o niego po nazwie.

   **Prompt do skopiowania: zaatakuj limiter**

   ```text
   Use the ecc:security-review skill on src/routes/auth/login.ts and src/lib/rate-limit.ts. Try to break the rate limit: account-name case or whitespace variants that get separate counters, a race between parallel requests that lets more than 5 attempts through, error paths that skip the increment, and whether the 429 response reveals that the account exists. For each finding, write a failing test first, then fix it.
   ```

5. **Napraw build, jeśli się wysypie, przez `/ecc:build-fix`.** Subagent `build-error-resolver` pracuje na wyjściu kompilatora i narzędzia uruchamiającego testy. Używaj go przy czerwonym buildzie, nie jako rutynowego kroku.

6. **Zapisz sesję przez `/ecc:save-session`**, zanim zamkniesz terminal, żeby `/ecc:resume-session` podjął pracę z nienaruszonym planem i decyzjami.

Gdy agent kończy pracę, ECC uruchamia kilka hooków `Stop`, w tym `stop:format-typecheck` (limit 300 sekund w `hooks/hooks.json`) i `stop:check-console-log` w profilach `standard` i `strict`. Traktuj je jako lokalne wczesne ostrzeżenie. To nie jest twoja bramka przed merge’em.

## Jak zweryfikować wynik ECC bez czytania każdej linii?

ECC zmusza agenta do pisania testów najpierw i do recenzji własnej pracy, ale recenzja przez model tego samego dostawcy to słaby dowód. Dowodem dla tej funkcji jest:

- **Testy akceptacyjne wpisane do planu**, widziane najpierw jako czerwone, potem jako zielone. Sprawdź czerwony przebieg w transkrypcie, a potem uruchom zestaw sam: `npm test -- tests/auth/login-rate-limit.test.ts`.
- **Bramki CI**, które działają z ECC i bez niego: sprawdzanie typów, lint, pełny zestaw testów i próg pokrycia, który zespół już egzekwuje.
- **Drugi recenzent z innego modelu**, np. `codex review` albo jeden z [botów do recenzji kodu](/pl/ecosystem/observability/ai-code-review-bots/), na pull requeście.
- **Ludzka akceptacja planu i testów**, nie diffu. Zatwierdzasz, że testy akceptacyjne opisują zachowanie, którego chcesz; bramki dowodzą, że kod je spełnia.

Jeśli czegoś z tej listy brakuje, ECC przyspieszył agenta, ale wynik nie stał się przez to bezpieczniejszy.

## Co zostawić, a co wyciąć

Większość zespołów używa małego wycinka ECC. Samo README mówi „Start with the workflow you need, not the full catalog”. Ten podział idzie za pętlą z przykładu powyżej.

| Zostaw | Dlaczego | Wytnij | Dlaczego |
| --- | --- | --- | --- |
| `/ecc:plan` i subagenta `planner` | Pisemny plan przed kodem, do przejrzenia w dwie minuty | Recenzentów i naprawiaczy dla języków, których nie używasz (Go, Python, F#, HarmonyOS/ArkTS i inne) | Każdy dodaje opis do każdej sesji |
| `tdd-workflow` z `tdd-guide` | Pętla „najpierw test” to źródło jakości | Polecenia `multi-*` | Wymagają zewnętrznego środowiska uruchomieniowego, którego ECC nie dołącza |
| `/ecc:code-review` z `code-reviewer` | Recenzja w świeżym kontekście przed twoją | Moduły dziedzinowe, w których nie pracujesz (np. `capability:machine-learning`) | Instalator nie bez powodu oferuje je jako opcjonalne moduły `--with` |
| `ecc:security-review` | Przegląd nastawiony na ataki dla wrażliwych ścieżek | Pakiety reguł poza `common` i jednym językiem | Reguły ładują się zawsze, więc każdy pakiet kosztuje kontekst |
| `verification-loop`, `search-first` | Sprawdź, zanim ogłosisz „gotowe”; poszukaj, zanim napiszesz | Wycofane aliasy poleceń (`legacy-command-shims/`) | Stare nazwy kolidujące z wbudowanymi, np. `/plan` |
| `/ecc:build-fix`, `context-budget` | Czerwone buildy i presja na kontekst | Środowisko uruchomieniowe hooków, dopóki go nie przeczytasz | Kod uruchamiany przy każdym wywołaniu narzędzia i zatrzymaniu |

Z wtyczką używaj poleceń `/ecc:`. W wersji odchudzonej wywołuj subagentów `planner`, `code-reviewer` i `build-error-resolver` po nazwie, a o przegląd bezpieczeństwa proś w prompcie („Use the security-review skill…”), nigdy przez polecenie `/security-review`, które pozostaje wbudowanym poleceniem Claude Code.

Żeby mieć kolumnę „zostaw” bez reszty, odinstaluj wtyczkę (`claude plugin uninstall ecc@ecc` w terminalu, Claude Code 2.1.283) i zainstaluj wybrane elementy z przejrzanego klonu. Instalator ECC przyjmuje listę skilli, a agenci to zwykłe pliki Markdown, które kopiujesz:

```bash
# Terminal, in the ECC clone
cd ~/src/ECC
node scripts/ecc.js consult "security reviews" --target claude   # which components match a job
# installs the skills at user scope (~/.claude/skills), per the README
./install.sh --target claude --skills tdd-workflow,security-review,verification-loop,search-first,context-budget
node scripts/ecc.js list-installed                               # what ECC now owns

# Terminal, in your service's repository: five subagents, project scope only
mkdir -p .claude/agents
cp ~/src/ECC/agents/{planner,tdd-guide,code-reviewer,security-reviewer,build-error-resolver}.md .claude/agents/
```

To dziesięć komponentów zamiast 454 skilli i agentów, bez środowiska uruchomieniowego hooków. Zwróć uwagę na różne zakresy: pięć skilli trafia do katalogu użytkownika i działa w każdym projekcie, a pięciu subagentów żyje tylko w tym repozytorium. Katalog `commands/` zostaw w spokoju: skopiowane ręcznie `plan.md` i `code-review.md` stają się poleceniami `/plan` i `/code-review` i kolidują z poleceniami samego Claude Code. Zamiast tego wywołuj subagentów po nazwie („Use the planner subagent to…”). Przy średniej wtyczki, około 90 stałych tokenów na wpis (41 515 na 454), dziesięć komponentów to mniej więcej 900 tokenów listy; potwierdź to u siebie, uruchamiając ponownie `/context`.

Jeśli chcesz całą pętlę przy mniejszej liczbie ruchomych części, polecenie z README `./install.sh --profile minimal --target claude` instaluje reguły, agentów, polecenia i podstawowe procesy bez środowiska uruchomieniowego hooków. Hooki dodaj później przez `--modules hooks-runtime --enable-hooks`, dopiero gdy je przeczytasz. Jeśli zostajesz przy wtyczce, `ECC_DISABLED_HOOKS` przyjmuje listę identyfikatorów hooków rozdzielonych przecinkami, a `ECC_SESSION_START_CONTEXT=off` wyłącza wstrzykiwanie kontekstu w `SessionStart`.

**Prompt do skopiowania: audyt tego, co ECC naprawdę zrobił**

```text
List every ECC skill, subagent and command that ran in this session, with how many times each ran. Then list the ECC hooks that fired and what each one changed or blocked. Finish with the ECC components that were loaded but never used. Do not change any files.
```

## Co się psuje, gdy używasz ECC?

**Wszystko pojawia się dwa razy.** Zainstalowałeś wtyczkę, a potem uruchomiłeś `./install.sh --profile full`, albo zsynchronizowałeś ECC do Codeksa i dodatkowo dodałeś wtyczkę w Codeksie. Wyjście: uruchom `claude plugin uninstall ecc@ecc`, potem `node scripts/ecc.js uninstall --dry-run` z klonu ECC, przeczytaj listę, uruchom bez `--dry-run` i zainstaluj ponownie jedną metodą.

**Uruchamia się niewłaściwe polecenie.** `/code-review`, `/plan` i `/security-review` to polecenia wbudowane w Claude Code (skill recenzji, tryb planowania i wbudowany przegląd bezpieczeństwa). Wersje z wtyczki to `/ecc:code-review`, `/ecc:plan` i skill `ecc:security-review`. Instalacje ręczne udostępniają krótkie nazwy i wycofany alias `/tdd`, które przesłaniają wbudowane polecenia albo z nimi kolidują. Wyjście: używaj form z przestrzenią nazw i nie kopiuj `legacy-command-shims/`.

**Agent wybiera zły skill.** Przy setkach opisów w kontekście ogólny prompt w rodzaju „review this” może uruchomić recenzenta dla niewłaściwego języka. Wyjście: nazwij skill w prompcie, tak jak robią to prompty powyżej, i wytnij pakiety, których nie używasz.

**Hook Stop zawiesza albo wywraca sesję.** `stop:format-typecheck` uruchamia formater i sprawdzanie typów z limitem 300 sekund, więc w dużym monorepo każde zatrzymanie może czekać na niego minutami. Wyjście: dopisz jego identyfikator do `ECC_DISABLED_HOOKS` i zostaw sprawdzanie typów w CI, gdzie jego miejsce.

**Koszty rosną po zastosowaniu porad kosztowych z README.** Sekcja ECC o optymalizacji tokenów zaleca `"model": "sonnet"`, limit `MAX_THINKING_TOKENS` i model Haiku dla subagentów, a oszczędności podaje bez źródła. To stoi w sprzeczności z tym, jak stroi się obecne modele: Claude Code domyślnie używa Claude Opus 5.5 z wysiłkiem `medium` (od v2.1.280 na obu kanałach wydań). Najpierw dostrój wysiłek przez `/effort`, dopiero potem zmieniaj model, i zmieniaj go tylko wtedy, gdy każą ci to własne ewaluacje. Wyjście: usuń te ustawienia i idź za [przeglądem modeli](/pl/ecosystem/models/).

**Podrobiony pakiet albo repozytorium.** Wyniki wyszukiwania podsuwają kopie z innych źródeł. Wyjście: instaluj tylko z nazw z ramki pułapek i przeskanuj konfigurację agenta narzędziem AgentShield z ECC (`agentshield scan --path .`, npm `ecc-agentshield` 1.6.0 na 2026-09-26) albo kontrolami ze strony o [bezpieczeństwie łańcucha dostaw skilli](/pl/ecosystem/skills/skill-security/).

## Kiedy ECC to zły wybór?

Wybierz ECC, gdy chcesz jednego, mocno opiniotwórczego harnessu i jesteś gotów go przyciąć. Wybierz coś mniejszego, gdy potrzebujesz jednej praktyki: [Superpowers](/pl/ecosystem/frameworks/superpowers/) kosztuje około 838 stałych tokenów za pełną pętlę projekt–plan–TDD–recenzja, a strona o [pakietach dyscypliny](/pl/ecosystem/frameworks/discipline-packs/) porównuje ECC ze skillami Matta Pococka, gstack, agent-skills i Ponytail. Jeśli potrzebujesz śladu specyfikacji zatwierdzanego przez product ownera, użyj [frameworka spec-driven](/pl/ecosystem/frameworks/spec-driven-frameworks/).

## Dokąd dalej z ECC

- [Frameworki pracy z agentami: porównanie](/pl/ecosystem/frameworks/) — ECC obok Superpowers, Spec Kit, BMAD, GSD i gstack: ceremonia, koszt i artefakty.
- [Najpopularniejsze wtyczki i ich koszt kontekstu](/pl/ecosystem/plugins/top-plugins/) — Zmierzone stałe tokeny wtyczek, które instaluje większość zespołów.
- [Harness: wszystko, w czym pracuje agent](/pl/workflows/harness/) — Gdzie siedzą hooki, skille, subagenci i wtyczki i jak recenzować je jak kod.
- [Okna kontekstu w praktyce](/pl/workflows/context/context-windows/) — Dlaczego stałe tokeny mają znaczenie, zanim okno się zapełni.
