Claude Skills
lucianobfs/claude-skills
Padrões de workflow multi-agente compostos para Claude Code
Ver no GitHubConjunto de skills compartilháveis para Claude Code que implementam 6 padrões de workflows dinâmicos multi-agente. Fornece building blocks como classify-and-act, fanout-and-synthesize, adversarial-verification, generate-and-filter, tournament e loop-until-done, além de composições prontas para implementação paralela, caça de bugs e upgrade de dependências.
Instalação
npx convez-ai lucianobfs/claude-skills1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Implementar features em paralelo com merge automático
- Verificar respostas através de adversarial verification
- Buscar bugs de forma exhaustiva com panel de validação
- Fazer triage de tarefas com classificação automática
- Atualizar dependências em batches com verificação de build
Veredito

Ferramenta robusta que traz patterns comprovados de orquestração multi-agente para Claude Code. A filosofia de publicar padrões compostos em vez de casos-use canned é sólida; ideal para quem constrói automações complexas que precisam de paralelização e verificação adversarial.
README
A tradução para o português deste README ainda está na fila.
claude-skills
Shareable skills for Claude Code (and other agents compatible with Agent Skills).
Install
npx skills add lucianobfs/claude-skills
The 6 dynamic-workflow patterns
The six building blocks from
"A harness for every task"
(Thariq Shihipar & Sid Bidasaria), each as its own slash-invocable skill, plus the wf guide:
| Skill | Pattern | args |
|---|---|---|
classify-and-act | a classifier routes the task to 1 of N handlers | { task, routes } |
fanout-and-synthesize | 1 agent per part (clean context) → a barrier synthesizes | { task, parts? } |
adversarial-verification | a worker produces, N skeptics try to refute it | { task, rubric?, verifiers? } |
generate-and-filter | parallel generators → filter dedupes + applies the rubric | { brief, rubric?, count? } |
tournament | N approaches compete → pairwise bracket → 1 winner | { task, approaches? } |
loop-until-done | keep spawning until a stop condition | { task, patience?, maxRounds? } |
wf | guide: when to use each pattern + how to compose use cases | — |
Reach for these often — not just for big jobs. A workflow beats a single context whenever a task has independent parts, deserves a second adversarial pass, is of unknown size, or could be approached from several angles: verifying an answer before you trust it, exploring a design, reviewing a diff, ranking options, hunting a root cause. Default to launching one.
Philosophy: we publish the patterns (building blocks), not canned use cases. A use case is a fixed
point in task-space — it limits you. The patterns compose and cover the long tail. The wf skill carries a
table of common use cases (doc verification, ranking, triage, root cause, …) and which patterns to combine
for each.
Usage: after installing, invoke directly by slash (/tournament ...) or just describe the task.
Capability skills (ready-made compositions)
Three higher-level skills ship alongside the building blocks. They are not new patterns — each is a composition you can invoke directly:
| Skill | Composes | What it does | args |
|---|---|---|---|
implement-fanout | fanout-and-synthesize, applied to writing | implement independent parts in parallel, each in its OWN git worktree → one agent merges them onto the base → ONE central verify (build/tests) → conditional single-thread fix loop | { task, parts?, verify?, fix?, … } |
bug-sweep | loop-until-done + adversarial-verification | find ALL the bugs in a scope (not just the first few), then a skeptic panel strips false positives — read-only, hand survivors to implement-fanout | { target, focus?, patience?, verifiers?, minSeverity? } |
dep-upgrade | drives implement-fanout | upgrade outdated/vulnerable deps in parallel batches → merge → verify that REGENERATES the lockfile + build/test | { task, parts, verify, … } |
implement-fanout and bug-sweep carry their own .workflow.js; dep-upgrade is a thin composition with
no engine of its own. All three need worktree/git isolation, so run them from INSIDE the target repo with a
clean tree.
Model/effort routing (agent types bundled in each skill, under agents/):
- Orchestrator: the session model (ideal: Fable)
wf-heavy: Opus @ effort xhigh — heavy work (investigation, verification, generation, action)wf-judge: Sonnet @ effort max — pairwise judges, classifiers, auditors
On first run, copy the two agent types into ~/.claude/agents/ (may require a session restart).
Cost & budget
Each part/claim/item becomes one or more Opus subagents at xhigh effort. Scale the fan-out to the job:
a few agents for a quick check, a larger pool when you ask for thoroughness. To cap it, state a ceiling in
your request ("use 200k tokens") — honored via budget.
License
MIT