Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

cc-agentic-patterns

/cc-agentic-patterns

Dobiera i wdraża wzorzec projektowy agentów, taki jak refleksja, łańcuch promptów, routing, równoległość, orchestrator-workers, evaluator-optimizer, ReAct i blackboard, w 5-warstwowym stosie Claude Code.

Repozytorium
claude ↗
Licencja
MIT
Ostatnia zmiana repozytorium
22.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Dobiera i wdraża wzorzec projektowy agentów, taki jak refleksja, łańcuch promptów, routing, równoległość, orchestrator-workers, evaluator-optimizer, ReAct i blackboard, w 5-warstwowym stosie Claude Code.

Wyzwalacze z opisu

which patternorchestrateparallel reviewself-reviewchain of thoughteval-optimizer loopblackboardReAct
Oryginalny opis (EN)

Select and wire an agentic design pattern (reflection, prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, ReAct, blackboard) into the 5-layer Claude Code stack. Use this skill whenever deciding how to structure a multi-step task, whether to spawn subagents, how to run parallel review, or when to use which pattern. Triggers on: "which pattern", "orchestrate", "parallel review", "self-review", "chain of thought", "eval-optimizer loop", "blackboard", "ReAct", "how to decompose this task".

Jak działa

  1. Choose by task shape
  2. Pattern quick-reference
  3. Wiring patterns into the 5-layer stack
  4. Pattern selection via router agent
  5. MCP delegation
  6. Parallelization vs Blackboard — when each applies
  7. Anti-patterns
Sekcje z nagłówków SKILL.md, w oryginale · 99 linii, 625 słów
Podgląd SKILL.md
---
name: cc-agentic-patterns
description: Select and wire an agentic design pattern (reflection, prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, ReAct, blackboard) into the 5-layer Claude Code stack. Use this skill whenever deciding how to structure a multi-step task, whether to spawn subagents, how to run parallel review, or when to use which pattern. Triggers on: "which pattern", "orchestrate", "parallel review", "self-review", "chain of thought", "eval-optimizer loop", "blackboard", "ReAct", "how to decompose this task".
---

# Agentic Patterns

13 patterns from Anthropic's workflow/agent taxonomy + Andrew Ng's four foundational patterns. This skill is the router; templates live in MCP `cc_kb_pattern_template(name)` and the `pattern-router` agent picks for you.

## Choose by task shape

```
How many distinct phases?
│
├─ 1 (single generation) ──────────────► REFLECTION
│
├─ 2-4 (sequential, each uses prior) ──► PROMPT CHAINING
│
├─ 2-4 (independent, same question) ───► PARALLELIZATION
│
├─ Branching on input type ────────────► ROUTING
│
├─ Quality must meet a rubric ─────────► EVALUATOR-OPTIMIZER
│
├─ Emergent subtasks, dynamic ─────────► ORCHESTRATOR-WORKERS
│
├─ Open debug / root-cause ────────────► ReAct (thought→action→observation)
│
├─ Multi-agent collaborative review ───► BLACKBOARD (council)
│
└─ Unsure? ────────────────────────────► use agents/cc-pattern-router
```

## Pattern quick-reference

| Pattern | Cost | Best for | Template |
|---|---|---|---|
| Reflection | 1.1× | Default quality gate on single shots | `cc_kb_pattern_template("reflection")` |
| Prompt chaining | 1.5–2× | Multi-phase features (analyze→plan→implement→verify) | `cc_kb_pattern_template("prompt-chaining")` |
| Routing | 1× | Task-type decides the branch | `cc_kb_pattern_template("routing")` |
| Parallelization | 1–3× | Independent parallel subtasks, fan-in synthesis | `cc_kb_pattern_template("parallelization")` |
| Evaluator-optimizer | 1.5–3× | Quality-critical artifacts (configs, security code) | `cc_kb_pattern_template("eval-optimizer")` |
| Orchestrator-workers | 2–5× | Large features where subtasks emerge during work | `cc_kb_pattern_template("orchestrator-workers")` |
| ReAct | 1.2–2× | Open-ended debugging, exploration | `cc_kb_pattern_template("react")` |
| Blackboard | 3–6× | Multi-agent collaborative review/synthesis | `cc_kb_pattern_template("blackboard")` |

## Wiring patterns into the 5-layer stack

Each pattern deploys artifacts across layers. Example for **reflection**:

| Layer | Artifact |
|---|---|
| L1 — CLAUDE.md | Add rule: "Review your own output before presenting. Check for off-by-one errors, unhandled edge cases, and inconsistency with existing code patterns." |
| L2 — Skill | None required — behavior driven from CLAUDE.md |
| L3 — Hook | Optional: PostToolUse on Write|Edit that prompts self-verify |
| L4 — Agent | `agents/cc-audit-reviewer` for explicit second-pass when risk is high |
| L5 — Memory | Save rejection reasons to engram for learning |

Fetch a specific pattern's full wiring via `cc_kb_pattern_template(name)`.

## Pattern selection via router agent

When the task is ambiguous, launch `pattern-router`:

```
Agent({
  subagent_type: "pattern-router",
  prompt: "Task: {...}. Select the optimal agentic pattern with rationale."
})
```

Router returns: pattern name + 5-layer wiring + cost estimate + anti-patterns.

## MCP delegation

| Need | Tool |
|---|---|
| Fetch pattern template | `cc_kb_pattern_template(name)` |
| Decide orchestration cost cap | `cc_docs_model_recommend(task, budget)` |
| Recommend topology for multi-agent | `cc_docs_team_topology_recommend(task, complexity, team_size)` |

## Parallelization vs Blackboard — when each applies

Both fan out to multiple agents. The difference is **whether agents read each other's work**:

| | Parallelization | Blackboard |
|---|---|---|
| Agents see peers? | No — each gets only their scope | Yes — each reads the shared board before writing |
| Subtasks | Fully independent | Overlapping; one agent's finding informs another |
| Example | Run security + perf + test reviews simultaneously | Security agent flags an issue; architecture agent reads it and re-evaluates their finding |
| Cost | 1–3× | 3–6× (extra rounds per agent) |
| When to choose | Subtasks have zero shared state | Agents must build on each other's output (adversarial or consensus-building) |

If in doubt: start with parallelization. Upgrade to blackboard only when a second round of cross-agent reasoning is demonstrably necessary.

## Anti-patterns

- Using eval-optimizer for simple tasks → wasted loops, no quality gain.
- Parallelization when subtasks share state → merge conflicts and hallucinated consistency.
- Orchestrator-workers for fixed-scope work → supervisor overhead dominates.
- ReAct with no stopping criterion → runs forever on fuzzy tasks.
- Blackboard with fewer than 3 agents → not actually multi-agent; just a chain with extra steps.

Wersje

W bazie nie ma innych skilli o nazwie cc-agentic-patterns.

Migawka bazy z 13.11.2026 · wersja paczki f7f5194c2508 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 95ai-agentic-workflows
    Projektuje przepływ sterowania wokół LLM: wybiera wzorzec, ogranicza pętle i wskazuje miejsca, w których człowiek sprawdza wynik.
  • 100agent-workflow-patterns
    Buduje systemy LLM ze składanych wzorców przepływu (łańcuchy promptów, routing, paralelizacja, orchestrator-workers, evaluator-optimizer) i pomaga wybrać między przepływem a autonomicznym agentem.
  • 95agentic-patterns
    Stosuje wzorce projektowe agentów, takie jak routing, planowanie, refleksja, blackboard i circuit breaker, do orkiestracji przepływów Jira w hierarchii 82 agentów.
  • 90agentic-patterns
    Wdraża wzorce agentowe AI: refleksję, ReAct, planowanie, pamięć i użycie narzędzi.
  • 100cc-orchestration-blackboard
    Udostępnia współdzieloną tablicę opartą na systemie plików dla uruchomień wieloagentowych, aby równoległe subagenty dopisywały ustalenia, a kolejne rundy czytały je przez narzędzia MCP bez wklejania do promptów.
  • 98agentic-eval
    Ocenia i ulepsza wyniki generowane przez AI jawnymi rubrykami, pętlami refleksji i warunkami zatrzymania: samokrytyka, potoki evaluator-optimizer i bramki akceptacji dla kodu, dokumentów, analiz i planów.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.