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.
- Autor
- TheLobbi ↗
- Repozytorium
- claude ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 22.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.
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
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
- Choose by task shape
- Pattern quick-reference
- Wiring patterns into the 5-layer stack
- Pattern selection via router agent
- MCP delegation
- Parallelization vs Blackboard — when each applies
- Anti-patterns
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.