convez.ai
SkillAutomaçãoIntermediário
lucianobfs

Claude Skills

lucianobfs/claude-skills

Padrões de workflow multi-agente compostos para Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

Conjunto 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-skills

1 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

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 4 meses
Versão
—
Issues abertas
0
Contribuidores
2

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:

SkillPatternargs
classify-and-acta classifier routes the task to 1 of N handlers{ task, routes }
fanout-and-synthesize1 agent per part (clean context) → a barrier synthesizes{ task, parts? }
adversarial-verificationa worker produces, N skeptics try to refute it{ task, rubric?, verifiers? }
generate-and-filterparallel generators → filter dedupes + applies the rubric{ brief, rubric?, count? }
tournamentN approaches compete → pairwise bracket → 1 winner{ task, approaches? }
loop-until-donekeep spawning until a stop condition{ task, patience?, maxRounds? }
wfguide: 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:

SkillComposesWhat it doesargs
implement-fanoutfanout-and-synthesize, applied to writingimplement 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-sweeploop-until-done + adversarial-verificationfind 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-upgradedrives implement-fanoutupgrade 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

Ver o original no GitHub

Bom para

Relacionados