O Superpowers (criado por Jesse Vincent) trouxe para o universo de agentes de inteligência artificial o que a engenharia de software tradicional levou décadas para consolidar: disciplina metódica. Em vez de deixar o modelo sair editando arquivos em frenesi, o framework impõe rituais inegociáveis: brainstorming estruturado antes de qualquer linha de código, TDD estrito (ver o teste falhar antes de implementar), depuração sistemática com isolamento de hipóteses e verificação compulsória com evidências antes de dizer que a tarefa acabou.
No entanto, o Superpowers original foi desenhado sob a premissa de um ambiente único (single-harness), como Claude Code ou Antigravity puro, executando subagentes in-process (invoke_subagent).
Quando levamos esse fluxo para projetos de grande porte dentro do Orca — um ambiente de desenvolvimento voltado especificamente para agentes (Agent Development Environment ou ADE) —, a abordagem de subagentes genéricos atinge um teto claro. Este artigo documenta os bastidores, a motivação técnica, as fases de desenvolvimento e a arquitetura do orca-superpowers, um fork projetado para unir a disciplina do Superpowers com o poder de orquestração em grafos (DAGs) e workers heterogêneos do Orca.
A Motivação: Por que os subagentes in-process atingiram o limite?
Subagentes executados dentro do mesmo processo do coordenador quebram o fluxo de engenharia em cinco pontos críticos:
- Poluição de Contexto e Falta de Isolamento: Subagentes genéricos herdam ou competem pela mesma janela de contexto do coordenador. O histórico infla rapidamente e o modelo perde a clareza sobre o escopo da tarefa atual.
- O Paradoxo da Auto-Revisão Homogênea: Se o mesmo modelo (por exemplo, Claude) implementa uma funcionalidade e dispara um subagente da mesma família para fazer code review, o revisor herda os mesmos vieses cognitivos e suposições cegas do autor. Modelos raramente pegam suas próprias falhas sutis de especificação.
- Bloqueio Síncrono por Dúvidas Humanas: Se um subagente encontra uma ambiguidade de negócio ou uma decisão destrutiva, a sessão inteira para ou o modelo tenta “adivinhar” a intenção do desenvolvedor, quebrando o princípio de alinhamento.
- Gargalo de Worktrees Manuais: O Superpowers upstream geria branches e isolamento criando diretórios
.worktrees/via scripts em Bash. Em ambientes com múltiplos agentes, isso gerava conflitos recorrentes de lock no Git, sujeira de arquivos temporários e quebra de referências de caminho. - Custo e Latência por Polling: O coordenador passava boa parte dos seus turnos perguntando "o subagente terminou?", queimando tokens de entrada e saída apenas para monitorar status.
A pergunta que disparou o projeto foi direta:
"É possível fazer um fork do Superpowers que funcione igual, mas melhor integrado com o Orca — que ao invés de usar subagents use os workers supervisionados, use diferentes agentes completamente heterogêneos, use o
gate-createe opere via DAGs?"
A resposta foi o orca-superpowers.
Os Estágios de Desenvolvimento
A construção do orca-superpowers passou por quatro fases bem documentadas, transitando de um plano arquitetural rigoroso em TDD até refinamentos cirúrgicos guiados por uso real (dogfooding).
flowchart TD
A["Estágio 1: Gênese & TDD da Base<br/>(Fork, Mapeamento Orca CLI, 6 Fases TDD)"] --> B["Estágio 2: Packaging & CI/CD<br/>(Sync Upstream automatizado, install.sh)"]
B --> C["Estágio 3: Teste em Batalha & Anti-Inércia<br/>(Detecção da falha de handoff, guardas forçadas)"]
C --> D["Estágio 4: WDD Lean & Otimização de Tokens<br/>(Helper wdd boot, catálogo compacto, 1-ação/wake)"]
Estágio 1: Arquitetura, Fork e TDD da Base
O ponto de partida foi um fork do repositório canônico obra/superpowers. Em vez de reescrever o código sem método, aplicamos o próprio Superpowers para construir a integração, gerando um plano de 6 fases executado estritamente com Test-Driven Development (TDD):
- Fase 1 (Mapeamento de Ferramentas): Criação de
skills/using-superpowers/references/orca-tools.md, mapeando verbos declarativos como "dispatch worker", "decision gate" e "create DAG" diretamente para a CLI do Orca (orca orchestration worker-start,gate-create,task-create). - Fase 2 (Worktrees Nativos): Implementação da skill
using-orca-worktrees. Em vez de scripts manuais de Git, o ambiente passou a usar--worktree currentpara workers locais e--worktree new-child --name <subsystem>para tarefas paralelas, com anotações de status na UI do Orca (orca worktree set --comment). - Fase 3 (Worker-Driven Development - WDD): Substituição completa da skill
subagent-driven-development. O WDD introduziu o ciclo de vida formal da orquestração:run-create --objective, decomposição em DAG comtask-create --depse despacho assíncrono viaworker-start. - Fase 4 (Orca Decision Gates): Criação de
orca-decision-gates. Integração comgate-createpara que dúvidas de arquitetura ou autorizações de segurança pausem apenas a tarefa em questão, permitindo que tarefas independentes no grafo continuem rodando. - Fase 5 (Cross-Agent Review & Workers Paralelos): Implementação de
cross-agent-review, que formaliza a regra de emparelhamento heterogêneo (o autor nunca revisa seu próprio código), edispatching-parallel-workerspara isolar falhas de testes e frentes desacopladas. - Fase 6 (Suíte de Verificação Unificada): Criação do script
tests/orca/run-all-orca-tests.shcobrindo validações sintáticas e de comportamento de ponta a ponta.
Estágio 2: Empacotamento, CI/CD e Sincronização Upstream
Para tornar o projeto utilizável tanto localmente quanto por outros engenheiros da comunidade, adicionamos infraestrutura de distribuição e manutenção contínua:
scripts/install.sh: Permite instalar os skills tanto no repositório local quanto globalmente (--global, apontando para~/.agents/skills), compatível com qualquer agente configurado no sistema.- GitHub Actions (
sync-upstream.yml): Um workflow agendado verifica diariamente novas releases e commits do repositório upstream (obra/superpowers). Ele executa rebase/merge automático, roda a suíte de testes do Orca e abre um Pull Request se houver novidades, garantindo que melhorias do projeto original sejam incorporadas sem sobrescrever os adaptadores do Orca. - CI (
ci.yml): Execução compulsória dos testes das skills e checagem de integridade dos manifests em cada push e PR.
Estágio 3: O Teste de Fogo e o "Gargalo da Inércia" (Dogfooding)
Ao colocar a nova versão para rodar em um projeto de backend real (fiscal-engine), surgiu um problema clássico de comportamento de LLMs: a inércia do plano.
Mesmo com a skill worker-driven-development perfeitamente instalada, o modelo coordenador, ao concluir a elaboração do plano em writing-plans, finalizava a mensagem sugerindo:
"Plan complete. Which execution approach would you prefer? Subagent-driven or Native?"
O modelo continuava caindo no hábito antigo herdado do texto original do Superpowers. Pior: se o desenvolvedor respondesse "continue", o agente caía em subagent-driven-development, ignorando a infraestrutura de workers do Orca.
A intervenção foi cirúrgica (commit f3b70e5):
- O skill
writing-plansfoi alterado para detectar a presença do Orca e declarar Worker-driven Development como padrão absoluto. - Adicionamos Hard Gates de Redirecionamento em
subagent-driven-development,dispatching-parallel-agentserequesting-code-review. Se qualquer um desses skills for acionado em um ambiente Orca, ele aborta imediatamente e força a troca paraworker-driven-developmentoucross-agent-review. - Escrevemos o teste
tests/orca/test-writing-plans-orca-handoff.shpara garantir que o handoff nunca mais desvie para subagentes.
Estágio 4: Otimização Radical de Tokens (Lean WDD e CLI wdd)
Com os workers funcionando, outro obstáculo prático apareceu durante execuções pesadas (como na automação de mídia em marketing/taniwha): o consumo excessivo de tokens pelo coordenador.
O coordenador gastava centenas de tokens executando comandos brutos como orca account list --json (que despeja dezenas de kilobytes de metadados de contas), lendo planos inteiros repetidas vezes a cada wakeup e escrevendo narrativas prolixas no terminal.
A solução foi estruturada em quatro melhorias integradas no skill:
- Protocolo "Lean Coordinator": O coordenador foi redefinido como um despachante de baixo custo cognitivo. Regra de ouro: 1 ação por wakeup -> encerra o turno imediatamente. O coordenador não resume nem re-lê o plano no "caminho feliz".
- Helper de Inicialização em Lote (
wdd boot): Em vez de o coordenador emitir dez comandos shell manuais para criar o run, ler as tarefas do markdown, criar cada task com suas dependências e despachar o primeiro worker, criamos o utilitáriowdd boot --plan <arquivo>. O script faz todo o setup do DAG de uma só vez. - Catálogo Compacto de Modelos (
model-catalog.yamlewdd models): Um arquivo local com mapeamento direto dos modelos suportados (ids-only), reduzindo a descoberta de ~1.5 KB para meros ~200 bytes. - Review Cruzada Seletiva: Code reviews heterogêneas completas (ex: Claude revisando Codex) passaram a ser acionadas apenas em tarefas críticas de borda, segurança ou arquitetura, poupando tokens em tarefas triviais.
Como Funciona a Arquitetura
A arquitetura do orca-superpowers transforma o plano de implementação em um grafo de computação vivo:
┌───────────────────────────────┐
│ Coordenador (Antigravity) │
│ - Mantém o objetivo global │
│ - Despacha via wdd / Orca │
└──────────────┬────────────────┘
│
orca orchestration run-create
orca orchestration task-create --deps
│
┌───────────────────────┴───────────────────────┐
▼ ▼
┌─────────────────────────────────┐ ┌─────────────────────────────────┐
│ Worker 1: Implementação │ │ Worker 2: Implementação │
│ Agent: Codex (CLI) │ │ Agent: Codex (CLI) │
│ Worktree: child-auth-service │ │ Worktree: child-db-models │
│ Executa TDD Red-Green-Refac │ │ Executa TDD Red-Green-Refac │
└────────────────┬────────────────┘ └────────────────┬────────────────┘
│ worker_done │ worker_done
▼ │
┌─────────────────────────────────┐ │
│ Worker 3: Cross-Agent Review │ │
│ Agent: Claude 3.7 / Opus │ │
│ Lê diff, valida constraints │ │
└────────────────┬────────────────┘ │
│ aprovação │
▼ ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│ Decision Gate: orca gate-create │
│ Humano escolhe estratégia no popup da IDE sem travar o DAG │
└─────────────────────────────────────────────────────────────────────────────────┘
1. A Matriz de Agentes Heterogêneos
Nenhum modelo é ótimo em tudo. O orca-superpowers explora as forças de cada provedor:
| Papel | Agente Recomendado | Por que usar |
|---|---|---|
| Coordenador / Arquiteto | antigravity / claude | Janela de contexto massiva, capacidade de síntese e raciocínio sistêmico. |
| Implementador (TDD) | codex | Velocidade imbatível em código e shell, iteração rápida no ciclo Red-Green. |
| Revisor de Código | claude | Rigor analítico contra edge-cases, vulnerabilidades de segurança e fidelidade à spec. |
| Depuração Profunda | devin | Exploração autônoma em repositórios legados com bugs não-determinísticos. |
2. Decision Gates Não-Bloqueantes
Quando uma tarefa precisa de uma decisão humana (ex: escolher entre autenticação via Cookie ou Token Bearer), o worker ou coordenador invoca:
orca orchestration gate-create \
--task task_auth_token \
--question "Qual o mecanismo de armazenamento de tokens?" \
--options '["Cookies HTTP-only (Recomendado)", "LocalStorage com refresh token"]'
Na interface do Orca, o desenvolvedor vê uma notificação limpa e pode clicar na opção desejada. Enquanto o gate não for resolvido, a tarefa dependente espera, mas todas as outras tarefas desacopladas do DAG continuam sendo executadas em paralelo.
3. Reatividade Pura por Eventos
Ao contrário de scripts tradicionais que ficam executando loops de while true; sleep 5, o coordenador do orca-superpowers simplesmente despacha os workers e executa um encerramento de turno (end turn).
O runtime do Orca é quem se encarrega de reativar o coordenador no momento exato em que um evento acontece:
worker_done: o worker concluiu a implementação e anexou as evidências do teste.ask: o worker tem uma dúvida objetiva sobre a tarefa.escalation: o worker falhou ou estourou o limite de tentativas.gate-resolved: o desenvolvedor respondeu a uma pergunta pendente.
Por que ele funciona tão bem com o Orca?
A sinergia entre o Superpowers e o Orca acontece porque o Orca foi construído desde o primeiro dia como um ADE (Agent Development Environment):
- Worktrees de Primeira Classe: Em vez de clones manuais do Git disputando permissões e arquivos
.git/index.lock, o Orca cria e destrói worktrees isolados transparentemente no nível do sistema de arquivos (--worktree new-child). - Multi-Tenancy Real de Modelos: O Orca autentica e gerencia as credenciais de múltiplos agentes (Codex, Claude, Cursor, Antigravity) no próprio aplicativo. O skill não precisa se preocupar com chaves de API individuais ou configurações de ambiente para alternar entre implementador e revisor.
- Visibilidade Operacional: Em vez de uma tela de terminal poluída por dezenas de saídas de subagentes concorrentes, cada worker no Orca tem sua própria aba, terminal e histórico auditável, além de visualização nativa de diffs.
- Economia de Contexto: Como cada worker roda em um terminal zerado recebendo apenas uma especificação focada e autocontida, o desperdício de tokens por contaminação de contexto cai para perto de zero.
Conclusão
O orca-superpowers demonstra que o futuro do desenvolvimento com IA não está em criar prompts cada vez mais gigantescos para um único modelo tentar resolver tudo sozinho. O futuro está na combinação de engenharia de processos rigorosa com infraestrutura de orquestração distribuída.
Ao unir o método científico do Superpowers (TDD, brainstorming, testes com evidências) com a infraestrutura reativa e multi-agente do Orca, transformamos tarefas complexas de software em linhas de montagem previsíveis, auditáveis e de alto rendimento.
Para entender como configurar o ecossistema completo de agentes e regras, confira os artigos complementares:
- Orquestração de agentes de código: quando 1 agente não basta
- Skills e Rules para agentes de IA: como padronizar o comportamento do time
- Worktrees e agentes em paralelo
- OpenCode vs Cursor vs Claude Code vs Orca: qual escolher em 2026
Quer ver como aplico essas práticas em sistemas de alta complexidade? Conheça meus projetos no portfólio.