Skills: Composição e Orquestração de Skills
Última atualização: 2026-08-31
Uma única Skill resolve um único problema — Skills compostas resolvem problemas complexos.
1. Padrões de Composição
(1) Cadeia de Skills (Pipeline)
Executar múltiplas Skills sequencialmente, onde a saída de uma é a entrada da próxima:
Exemplo de Cadeia de Skills: Processo Completo de Commit de Código
Revisão de Código → Auto Correção → Executar Testes → Atualizar Docs → Commit Código
↓ ↓ ↓ ↓ ↓
Relatório Rev. Patch Correção Relatório Testes Doc Atualizada commit ID
(2) Matriz de Skills (Matrix)
Múltiplas Skills executam em paralelo, resultados agregados:
Exemplo de Matriz de Skills: Verificação Abrangente de Qualidade
┌→ Scan de Segurança ─┐
Mudança Código ──┤→ Análise Performance ─┤→ Relatório de Qualidade
└→ Verificação Estilo ─┘
(3) Orquestração Condicional
Selecionar caminho de execução baseado em condições:
Exemplo de Orquestração Condicional: Deploy Inteligente
Determinação do tipo de mudança:
├── Mudança de doc → Apenas atualizar docs
├── Mudança de teste → Apenas executar testes
├── Mudança de código → Processo completo (revisão→testes→deploy)
└── Mudança de config → Revisão + confirmar e então deploy
2. Implementação de Composição
(1) Orquestração por Prompt
Descrever lógica de composição no prompt da Skill:
## Estratégia de Execução
1. Primeiro executar Skill code-review
2. Se encontrar problemas 🔴:
- Executar Skill auto-fix
- Re-executar code-review para confirmar correção
3. Após revisão passar, executar Skill test-runner
4. Após testes passarem, gerar relatório resumo
(2) Passagem de Contexto
Skills passam dados através do contexto:
Saída Skill A → Escrever em variável de contexto → Skill B lê
Exemplo:
code-review encontra 3 problemas →
context: { review_issues: [...], fix_targets: [...] }
→ auto-fix lê fix_targets e executa correções
(3) Agregação de Resultados
## Template de Relatório Resumo
### Resultados da Execução da Cadeia de Skills
| Etapa | Skill | Status | Duração | Saída Principal |
|:------|:------|:-------|:--------|:----------------|
| 1 | code-review | ✅ | 30s | 5 problemas |
| 2 | auto-fix | ✅ | 45s | Corrigidos 4 |
| 3 | test-runner | ✅ | 2m | Todos passaram |
3. Princípios de Design de Composição
(1) Baixo Acoplamento
Cada Skill é independentemente utilizável, não dependendo da implementação interna de outras Skills:
Design de Baixo Acoplamento:
├── Skill A não chama diretamente funções internas da Skill B
├── Skills passam dados via formatos padrão (ex.: JSON, Markdown)
├── Falha de uma Skill não afeta a funcionalidade básica das outras
└── Cada Skill pode ser testada independentemente
(2) Responsabilidade Única
Cada Skill faz uma coisa e faz bem:
| ✅ Correto | ❌ Errado |
|---|---|
| code-review apenas revisa | code-review revisa+corrigi+testa |
| auto-fix apenas corrige | auto-fix corrige+revisa+implanta |
| deploy apenas implanta | deploy implanta+monitora+alerta |
(3) Idempotência
Execuções repetidas produzem resultados consistentes, suportando retentativas seguras:
## Requisitos de Idempotência
- Múltiplas execuções da Skill de review produzem os mesmos resultados
- Skill de correção verifica se o problema já foi corrigido, pula se sim
- Skill de deploy verifica estado atual, confirma ao invés de re-implantar se já implantado
4. Prática de Orquestração de Composição
▶ Exemplo: Portão de Qualidade de PR
Alice projetou uma composição de revisão automática de PR:
---
name: pr-gate
description: "Portão de qualidade de PR: revisão+testes+segurança três em um"
triggers:
- keyword: "pr-gate|quality gate"
---
## Fluxo de Execução
1. Chamar code-review (revisão de código)
2. Chamar test-runner (executar testes)
3. Chamar security-scan (scan de segurança)
4. Agregar resultados dos três
5. Gerar recomendação de merge:
- Todos três passaram → ✅ Recomendar merge
- Qualquer 🔴 → ❌ Não recomendar merge
- Apenas 🟡 → ⚠️ Merge após correções
Bob comentou: "Uma Skill isolada é uma ferramenta, Skills compostas são um pipeline — o poder de um pipeline supera em muito a soma simples de ferramentas individuais."
❓ Perguntas Frequentes
P: Skills podem chamar umas às outras diretamente? R: Depende da plataforma. Claude Code suporta descrever lógica de chamada nos prompts; OpenCode requer orquestração manual. O núcleo é passagem de dados, não chamada de funções. P: Como manter composições excessivamente complexas? R: Limitar profundidade de aninhamento ≤2, Skills de composição ≤5. Além disso, considere dividir em workflows independentes ou usar ferramentas de orquestração dedicadas. P: E se uma Skill falhar em uma cadeia? R: Falha no caminho crítico (revisão, testes) para tudo; falha no caminho não crítico (docs, notificações) registra e continua. Use classificação de erros para decidir.
📖 Resumo
- Três tipos de composição: Cadeia de Skills (sequencial), Matriz de Skills (paralela), orquestração condicional
- Implementação: Orquestração por prompt, passagem de contexto, agregação de resultados
- Princípios de design: Baixo acoplamento, responsabilidade única, idempotência
- Conselhos práticos: Aninhamento ≤2, composição ≤5, falha no caminho crítico para tudo
📝 Exercícios
- Básico (⭐): Crie uma cadeia de skills simples conectando as Skills code-review e test-runner.
- Intermediário (⭐⭐): Crie uma Skill de portão de qualidade de PR que executa revisão, testes e scan de segurança em paralelo, então agrega resultados.
- Avançado (⭐⭐⭐): Projet um sistema de orquestração inteligente que seleciona automaticamente quais Skills executar com base no tipo de mudança, tratando falhas e retentativas no meio do processo.
