Testei o Superpowers para Claude Code — eis o que realmente achei

Quase ignorei o Superpowers. Mais uma framework de habilidades, mais um repositório no GitHub prometendo “revolucionar” meu fluxo de trabalho com IA para programação. Já vi uma dúzia dessas irem e virem — READMEs chamativos, demos impressionantes, abandonadas após três meses. Então, quando o framework de Jesse Vincent começou a ganhar estrelas no GitHub mais rápido do que qualquer coisa que já tinha visto no ecossistema do Claude Code, minha primeira reação foi ceticismo.

Foi aí que decidi fazer um experimento. Doze sessões com Claude Code: seis com o Superpowers instalado, seis sem. Mesmas tarefas. Mesmos prompts. Mesmo limite de gasto de $2 por execução. Zero intervenção humana — totalmente automatizado, para que meus próprios vieses não contaminassem os resultados.

Os números contaram uma história que eu não esperava. Não era a história de “10x mais produtividade” que o hype faz parecer. Era algo mais sutil, mais útil e, honestamente, mais interessante. O Superpowers não deixou o Claude mais inteligente. Ele tornou o Claude disciplinado — e a diferença entre inteligência e disciplina acabou sendo o abismo com o qual eu vinha lutando há meses sem perceber.

Aqui está tudo o que descobri, incluindo as partes que a maioria das análises convenientemente ignora.

Testei o Superpowers para Claude Code — eis o que realmente achei

Se você já passou algum tempo de verdade com o Claude Code, já viu esse padrão se repetir. Você descreve o que quer. O Claude imediatamente começa a escrever código. Quinze minutos e 40.000 tokens depois, você percebe que ele entendeu errado seus requisitos nos primeiros trinta segundos. Todo o output é um código tecnicamente correto que resolve o problema errado.

Acompanhei isso nos meus próprios projetos no último trimestre. Aproximadamente 35% das minhas sessões com Claude Code exigiram pelo menos uma grande correção de rumo — não porque o modelo fosse burro, mas porque ele pulava direto para a implementação sem parar para pensar. Nada de levantamento de requisitos. Nada de consideração de arquitetura. Nenhum plano. Só código, código, código, torcendo pelo melhor.

Soa familiar? Você não está sozinho. Esse é o comportamento padrão de todo agente de programação que já testei. Inteligência bruta aplicada sem metodologia. É como contratar um engenheiro brilhante que se recusa a ler a especificação antes de escrever a primeira linha.

Jesse Vincent — líder do projeto Perl e fundador da Keyboardio, que criou o Superpowers — identificou exatamente esse modo de falha. A solução dele não foi tornar o modelo mais inteligente. Foi impor a mesma disciplina que um líder de engenharia sênior exigiria de um desenvolvedor júnior: pare, pense, planeje, depois construa.

Essa distinção importa mais do que qualquer funcionalidade individual do framework. E entendê-la é a chave para saber se o Superpowers realmente vai ajudar no seu fluxo de trabalho ou só adicionar burocracia.

Mas antes de entrar na arquitetura, você precisa entender como esse framework saiu de um repositório de nicho no GitHub para 121.000 estrelas em questão de meses — porque essa trajetória revela algo importante sobre uma dor que toda a comunidade estava sentindo.

De Projeto Paralelo a 121.000 Estrelas no GitHub

O Superpowers não foi lançado com uma campanha de marketing. Jesse Vincent publicou-o no GitHub como obra/superpowers, descrevendo-o como “um framework de habilidades agenticas & metodologia de desenvolvimento de software que funciona”, e deixou lá. Os primeiros adeptos foram desenvolvedores que já acompanhavam seu trabalho na Keyboardio e na comunidade Perl.

Então algo aconteceu. O repositório começou a ganhar quase 2.000 estrelas por dia em seu auge. Em janeiro de 2026, a Anthropic o aceitou oficialmente no marketplace de plugins do Claude. Em março, já havia ultrapassado 94.000 estrelas. Em abril de 2026, já soma mais de 121.000 — tornando-se um dos projetos open-source de crescimento mais rápido do ano e garantindo o segundo lugar entre os mais populares do GitHub.

Por quê? Porque Jesse não estava vendendo uma ferramenta. Ele estava articulando uma metodologia que refletia o que desenvolvedores experientes já sabiam, mas não conseguiam impor aos seus agentes de IA: você planeja antes de construir. Você testa antes de lançar. Você verifica antes de considerar pronto.

O framework acabou sendo apenas o veículo para essa metodologia. E, uma vez que os desenvolvedores experimentaram, a notícia se espalhou organicamente.

Ouvi falar dele pela primeira vez por meio de um colega, que me contou que a qualidade do código na primeira tentativa aumentou cerca de 40% após uma semana usando o Superpowers. Fiquei cético quanto a esse número. Depois de realizar meus próprios testes, acho que ele é, na verdade, conservador para tarefas complexas — e significativamente exagerado para tarefas simples. A realidade, como sempre, é mais complexa do que um único percentual pode sugerir.

Deixe-me mostrar o que realmente está dentro da caixa.

O que é, de fato, o Superpowers (E o que não é)

Superpowers não é uma habilidade única. É um sistema — 14 habilidades interconectadas que se instalam no Claude Code e orquestram um fluxo de trabalho completo de desenvolvimento de software. Pense menos como instalar um plugin e mais como incorporar um processo de engenharia sênior ao seu agente.

O framework impõe cinco fases em toda interação:

Clarify — Antes de escrever uma única linha de código, o agente faz perguntas. Não perguntas genéricas do tipo “o que você quer?”. São esclarecimentos específicos e direcionados, projetados para revelar ambiguidades no seu pedido que, de outra forma, se tornariam bugs mais tarde. Nos meus testes, essa fase identificou lacunas de requisitos em cerca de 60% das vezes — pontos que eu mesmo não havia percebido no meu prompt.

Design — É aqui que o Superpowers realmente se destaca. O agente gera companheiros visuais — dashboards interativos com force graphs, grades de cartões e layouts de opções — para ajudar você a visualizar a arquitetura antes de se comprometer com ela. Você escolhe entre várias abordagens de design, e o agente usa sua seleção para guiar a construção. Para ser sincero: na primeira vez que vi isso em ação, achei que era só um truque. Na terceira sessão, já estava convencido. Visualizar a arquitetura antes de começar a codificar elimina toda uma categoria de mal-entendidos.

Plan — O agente cria planos de implementação hiper-detalhados. Não são esboços vagos — são divisões reais de tarefas, com estimativas de 2 a 5 minutos para conclusão, caminhos exatos de arquivos, assinaturas específicas de funções e ordenação de dependências. Esses planos são salvos para referência futura, então, se sua sessão travar ou você quiser retomar depois, o roteiro já está pronto.

Code — É aqui que a metodologia mostra seu valor. Em vez de um sprint monolítico de codificação, o Superpowers divide a execução em tarefas discretas e despacha subagentes novos para cada uma. Tarefas independentes podem rodar em paralelo. Cada tarefa tem pontos de verificação — checkpoints onde o agente pausa para verificar se ainda está no caminho certo antes de continuar. Essa arquitetura de subagentes significa que uma falha em uma tarefa não contamina toda a sessão.

Verify — A fase final executa suítes de testes, verifica se todos os requisitos da fase de esclarecimento foram atendidos e valida a estrutura do código antes de declarar o trabalho concluído.

A habilidade principal — chamada “Using Superpowers” — atua como orquestradora. Sempre que você inicia uma interação no Claude Code, ela lê seu pedido e decide qual das 14 habilidades acionar. Você não precisa acionar fases manualmente. O sistema faz o roteamento automaticamente.

Aqui está o que o Superpowers não é: não é um template de prompt. Não é um arquivo CLAUDE.md cheio de instruções. As habilidades são módulos executáveis e composáveis que incluem enforcement de desenvolvimento orientado a testes, protocolos sistemáticos de depuração e — essa parte me surpreendeu — uma meta-habilidade que permite ao Claude criar novas habilidades Superpowers usando princípios de TDD. O framework pode se estender sozinho.

Se você acompanha minha cobertura sobre arquitetura de habilidades de agentes, vai reconhecer aqui o padrão de divulgação progressiva. O Superpowers não despeja todas as 14 habilidades na janela de contexto de uma vez. O orquestrador carrega apenas a habilidade relevante para cada fase, mantendo o uso de tokens enxuto. Essa escolha de design é um dos principais motivos pelos quais o framework realmente economiza tokens, em vez de desperdiçá-los com overhead.

Agora, sobre essa economia de tokens — é aqui que preciso ser honesto sobre o que os números realmente mostram.

O Experimento de 12 Sessões: O Que os Números Realmente Revelam

Eu queria dados concretos, não impressões subjetivas. Por isso, elaborei uma comparação controlada: 12 sessões do Claude Code, 6 com o Superpowers ativado e 6 sem. Cada lote incluiu duas tarefas simples (utilitários de arquivo único), duas tarefas médias (funcionalidades multi-arquivo com integração de API) e duas tarefas complexas (funcionalidades full-stack com alterações de esquema de banco de dados, autenticação e componentes de UI).

Cada sessão foi executada com um limite de gasto de $2. Zero intervenção humana. Mesmos prompts, mesmo modelo, mesmas restrições. A única variável era se o Superpowers estava ativo ou não.

Veja o que os resultados mostraram:

Custo e Eficiência de Tokens

O custo médio nas 6 sessões com Superpowers foi aproximadamente 9% menor do que nas 6 sessões de base. Isso representa uma economia real se você executa dezenas de sessões diariamente, mas está longe das economias dramáticas prometidas por algumas análises.

A questão dos tokens é mais complexa. No geral, as sessões com Superpowers usaram cerca de 14% menos tokens em média. Mas essa média esconde um padrão importante:

Tarefas simples na verdade usaram mais tokens com o Superpowers. As fases de esclarecimento e design adicionaram uma sobrecarga desnecessária para tarefas do tipo “escreva uma função utilitária”. O framework fazia perguntas de esclarecimento sobre um problema que não tinha ambiguidade. Planejava uma arquitetura para algo que cabia em um único arquivo. A disciplina era genuína — mas para um script de 50 linhas, era exagero.

Tarefas médias ficaram praticamente empatadas em uso de tokens, mas geraram códigos visivelmente melhores. A sobrecarga do planejamento foi compensada por menos ciclos de correção depois.

Tarefas complexas apresentaram uma economia significativa de tokens — e é aqui que o Superpowers justifica sua reputação. As fases de planejamento (esclarecimento, design, plano) consumiram poucos tokens — quase todo texto, sem geração de código. Mas evitaram o modo de falha caro que descrevi antes: escrever milhares de linhas de código que resolvem o problema errado. Sem o Superpowers, tarefas complexas frequentemente exigiam vários ciclos de reinício. Com ele, o agente acertava muito mais vezes já na primeira tentativa de implementação.

A Descoberta Sobre Variância Que Mudou Minha Opinião

Aqui está o dado que realmente me converteu de cético a usuário diário.

A variância no uso de tokens nas 6 sessões com Superpowers foi de 2 a 3 vezes menor do que nas sessões de base. Em outras palavras: sem o Superpowers, minhas tarefas complexas eram totalmente imprevisíveis. Uma sessão custava $0,80, a próxima batia o limite de $2 em uma tarefa semelhante. Com o Superpowers, os custos das sessões ficavam concentrados em torno do mesmo valor.

Por que isso importa? Porque previsibilidade vale o investimento. Quando estou dimensionando um projeto e estimando custos de desenvolvimento assistido por IA, preciso saber aproximadamente quanto uma funcionalidade vai custar em tokens. O Superpowers tornou essa estimativa confiável. As sessões de base eram basicamente uma moeda lançada ao ar.

Round Trips de API

As sessões com Superpowers fizeram menos round trips de API em média. Isso faz sentido — menos ciclos de correção significam menos trocas de ida e volta. Cada round trip traz latência e sobrecarga de tokens, então menos viagens se traduzem em economia de custo e tempos de conclusão mais rápidos.

Pontuação de Qualidade do Código

Avaliei a saída de cada sessão em quatro dimensões: correção, estrutura do código, cobertura de testes e tratamento de erros. As sessões com Superpowers tiveram pontuações visivelmente superiores em correção, estrutura e cobertura de testes. A melhoria na cobertura de testes foi especialmente notável — a skill TDD integrada faz com que os testes sejam escritos primeiro, e não adicionados depois (ou ignorados, como acontece na maioria das sessões de base).

Uma descoberta surpreendente: robustez — quão bem o código lidava com casos extremos e entradas inesperadas — foi ligeiramente melhor nas sessões de base. Minha hipótese? A abordagem estruturada às vezes superotimiza para o caminho feliz planejado. Sem o framework, o agente ocasionalmente explorava casos extremos com mais liberdade, já que não seguia um plano predeterminado. Esse é um trade-off real que vale a pena conhecer.

Quero ser transparente quanto às limitações deste experimento. Doze sessões não constituem uma amostra estatisticamente significativa. As tarefas foram criadas por mim, o que introduz viés. E, fundamentalmente, o experimento foi totalmente automatizado — mas o Superpowers foi projetado para iteração com o humano no loop. As perguntas de esclarecimento, a seleção de design, a revisão do plano — são pontos de interação onde a participação do desenvolvedor torna o framework muito mais eficaz. Meu teste automatizado ignorou tudo isso.

Considere meus números como indicadores de tendência, não como verdade absoluta. Os ganhos reais aparecem quando você colabora ativamente com o framework, não apenas deixando ele rodar no piloto automático.

Falando em colaboração — deixe-me mostrar como é, na prática, a instalação e o uso diário.

Instalando o Superpowers: Mais Rápido do Que Você Imagina

A instalação leva cerca de 30 segundos. Você tem dois caminhos:

Opção 1: Marketplace de Plugins do Claude

Se você está usando o Claude Code com acesso ao marketplace, este é o caminho mais simples:

/plugin install superpowers@claude-plugins-official

Um comando. Pronto. O Superpowers fica ativo em todas as suas sessões do Claude Code.

Opção 2: Diretamente do GitHub

Se você prefere instalar a partir do código-fonte ou quer personalizar as skills:

# Clone o repositório
git clone https://github.com/obra/superpowers.git

# Instale globalmente no nível do usuário (recomendado)
claude plugins install --global ./superpowers

Jesse recomenda instalar globalmente no nível do usuário, em vez de por projeto. Concordo — você quer a metodologia disponível em qualquer lugar, não apenas em repositórios específicos. As skills são suficientemente gerais para melhorar qualquer fluxo de trabalho de programação.

Opção 3: Terminal do VS Code

Se você utiliza o Claude Code pelo terminal do VS Code (minha preferência, pela visibilidade que oferece ao fluxo de trabalho):

# Abra o terminal do VS Code e execute
claude plugin add obra/superpowers

Após a instalação, o Superpowers roda automaticamente em segundo plano. Não é necessário invocá-lo explicitamente. A skill principal "Using Superpowers" intercepta seus pedidos e os direciona pelas fases apropriadas. Se quiser uma garantia extra, pode adicionar "use any relevant superpower skills" aos seus prompts — mas, na minha experiência, a detecção automática é confiável o suficiente para tornar isso desnecessário.

Um ponto que gostei: o Superpowers não entra em conflito com outras skills ou plugins que você já tenha instalado. Eu o utilizo junto com minhas skills personalizadas de SEO e várias skills específicas de projetos, sem conflitos. O orquestrador é inteligente o bastante para saber quando outra skill deve assumir o pedido.

Se você preferir que alguém configure todo o seu ambiente de desenvolvimento Claude Code — Superpowers, skills personalizadas, configurações específicas de projeto — eu faço esse tipo de trabalho. Você pode ver o que já construí em fiverr.com/s/EgxYmWD.

Agora vamos falar sobre o recurso que mais me surpreendeu durante os testes.

O Companheiro Visual: Por Que Passei de Cético a Convertido

Nas duas primeiras sessões, descartei o companheiro visual como um mero truque. Dashboards interativos? Grafos de força? Grades de cartões? Parecia apenas um enfeite de UI em cima de um fluxo de trabalho que deveria ser orientado ao terminal.

Então me deparei com uma tarefa complexa — um recurso SaaS multi-inquilino com controle de acesso baseado em funções, registro de auditoria e um sistema de permissões personalizado. Aquele tipo de funcionalidade em que você pode interpretar os requisitos de três maneiras diferentes, e cada interpretação leva a uma arquitetura fundamentalmente distinta.

O Superpowers gerou um companheiro visual mostrando três abordagens de design como cartões interativos. Cada cartão apresentava a arquitetura de forma visual — modelos de dados, endpoints de API, hierarquia de componentes, fluxo de permissões. Eu conseguia enxergar os trade-offs instantaneamente. A Opção A era mais simples, mas não escalava além de 50 inquilinos. A Opção B lidava com escala, mas adicionava complexidade significativa ao banco de dados. A Opção C ficava no meio-termo com uma camada de cache.

Sem o companheiro visual, eis o que teria acontecido: o Claude escolheria a interpretação que julgasse “mais provável”, codificaria tudo, e eu só descobriria o desalinhamento arquitetural depois de 2.000 linhas de código. Com o companheiro visual, identifiquei a abordagem certa em cerca de 45 segundos e o agente construiu exatamente o que eu precisava já na primeira tentativa.

As perguntas de esclarecimento funcionam de forma semelhante. O Superpowers não pergunta apenas “você quer o recurso X?” Ele destaca as ambiguidades específicas do seu pedido que um desenvolvedor sênior perceberia em uma revisão de código. Em uma das sessões, ele me perguntou se o requisito de “autenticação de usuário” significava autenticação baseada em sessão, tokens JWT ou OAuth2 — e então explicou as implicações de cada opção para o restante da arquitetura. Eu não tinha especificado porque ainda não havia pensado nisso. Essa única pergunta economizou um ciclo inteiro de implementação.

Esse é o design com humano no loop que mencionei anteriormente. O framework é projetado para esses momentos de interação. Se você os ignora (como meu teste automatizado fez), perde uma parte significativa do valor.

As 14 Habilidades: O Que Cada Uma Realmente Faz

A maioria das análises lista as habilidades sem explicar quando elas são acionadas ou por que são importantes. Aqui está o detalhamento com base no que observei durante meus testes:

O Orquestrador

Usando Superpowers — O despachante mestre. Ele lê todo prompt que você envia e decide quais habilidades invocar. Isso roda automaticamente em toda interação. Você nunca o chama diretamente; é o controlador de tráfego.

Habilidades da Fase de Design

Brainstorming — Gera opções de design com acompanhamentos visuais. Produz listas de verificação detalhadas que a fase de planejamento usa como insumo. Essa habilidade é acionada antes de qualquer trabalho de implementação e é responsável pelos grids interativos de cartões e grafos de força que descrevi acima.

Habilidades da Fase de Planejamento

Writing Plans — Cria planos de implementação hiper-detalhados. Cada plano divide o trabalho em tarefas estimadas em 2-5 minutos, inclui caminhos de arquivos exatos e assinaturas de funções, especifica dependências entre tarefas e é salvo como um documento de referência. Passei a usar esses planos salvos como especificações técnicas leves para meus projetos.

Executing Plans — Pega um plano escrito e coordena a execução. É aqui que a arquitetura de subagentes entra em ação — a habilidade despacha novos agentes Claude Code para cada tarefa do plano, gerencia suas saídas e integra as tarefas concluídas.

Habilidades da Fase de Execução

Subagent-Driven Development — Despacha subagentes independentes para execução paralela de tarefas. Se seu plano tem três tarefas sem dependências entre elas, essa habilidade executa todas simultaneamente. A melhoria de velocidade em projetos complexos é notável — o tempo total cai substancialmente quando tarefas independentes não precisam esperar umas pelas outras.

Dispatching Parallel Agents — A camada de coordenação para execução paralela. Gerencia o estado entre subagentes concorrentes, garante que tarefas concluídas não entrem em conflito e faz o merge das saídas paralelas.

Habilidades de Qualidade

Test-Driven Development — Esta habilidade impõe a metodologia TDD: escrever testes que falham primeiro, depois o código mínimo para fazê-los passar, e então refatorar. Nos meus testes, foi o maior fator para melhorar a qualidade do código. Sem ela, o Claude Code escreve a implementação primeiro e os testes depois (se escrever). Com ela, toda feature começa com uma definição clara de "pronto" expressa como testes executáveis.

Systematic Debugging — Quando algo quebra, essa habilidade impõe um protocolo de depuração em quatro fases: identificar a causa raiz, analisar sistemas relacionados, gerar hipóteses e testar a correção. Isso evita o padrão de "shotgun debugging", onde o agente faz mudanças aleatórias esperando que algo funcione. Já vi essa habilidade salvar sessões inteiras que, de outra forma, teriam virado ciclos de correção queimando tokens.

Verification Before Completion — O portão final de qualidade. Antes que o Superpowers declare qualquer trabalho como concluído, essa habilidade exige rodar a suíte de testes, verificar se todos os requisitos da fase de esclarecimento foram atendidos e confirmar que o código compila e roda. Chega de "terminei" seguido de falhas imediatas.

Habilidades de Revisão de Código

Requesting Code Review — Aciona quando a implementação está concluída. Executa uma revisão estruturada verificando correção, estilo, performance e segurança antes do código ser commitado.

Receiving Code Review — Lida com feedbacks de revisão de código com o que Jesse chama de "rigor técnico, não concordância performática". A habilidade avalia os comentários de revisão de forma crítica, em vez de implementar cegamente toda sugestão. Isso evita o padrão em que o feedback de revisão piora o código porque o agente não contesta sugestões ruins.

Habilidades de Workflow com Git

Using Git Worktrees — Cria worktrees isolados do git para desenvolvimento de features. Mantém seu workspace principal limpo enquanto experimentos rodam em branches separados. Seleção inteligente de diretórios e verificação de segurança evitam a proliferação de worktrees que a gestão manual costuma causar.

Finishing a Development Branch — Guia a finalização do trabalho de desenvolvimento apresentando opções estruturadas: fazer merge para a main, criar um PR ou limpar a branch. Isso previne o erro comum de deixar branches inacabadas poluindo seu repositório.

A Meta Habilidade

Writing Skills — Esta é a que empolga entusiastas de frameworks de IA. O Superpowers pode escrever novas habilidades do próprio Superpowers usando princípios de TDD. Você descreve a capacidade desejada e o framework cria uma habilidade testada e verificada, integrada ao restante do sistema. O framework se estende sozinho. Já usei isso para criar habilidades específicas de projeto que seguem as convenções do Superpowers e integram com sua camada de orquestração.

A Avaliação Honesta: Onde o Superpowers Deixa a Desejar

Toda análise que li sobre o Superpowers foca nas vitórias. Aqui está o que elas não contam.

Tarefas simples ficam mais lentas, não mais rápidas. Se você precisa de uma função utilitária rápida, um script pontual ou um refator simples, o overhead de esclarecimento, design e planejamento adiciona tempo sem agregar valor. Comecei a prefixar pedidos simples com “tarefa rápida, pule o planejamento:” e o orquestrador respeita isso na maioria das vezes. Mas, por padrão, o Superpowers não diferencia uma correção de 10 linhas de uma feature de 10.000 linhas. Ele aplica toda a metodologia em ambos os casos.

O conhecimento de domínio não melhora. O Superpowers torna o Claude mais disciplinado, não mais conhecedor. Se o modelo não entende seu framework específico, seu domínio de negócio ou suas APIs proprietárias, o Superpowers não vai resolver isso. Ele apenas planeja com mais cuidado em torno dessas lacunas de conhecimento — o que é melhor do que programar às cegas, mas as lacunas continuam existindo. Você ainda precisa fornecer contexto específico do domínio nos seus prompts ou no CLAUDE.md.

A conformidade com o escopo não muda. Se seus requisitos estão errados ou incompletos, o Superpowers vai planejar e executar fielmente com base nesses requisitos errados ou incompletos. As perguntas de esclarecimento ajudam — elas capturam algumas lacunas — mas não substituem uma especificação bem escrita. Vi o framework construir uma feature perfeitamente planejada, perfeitamente executada, que era exatamente o que pedi e totalmente diferente do que eu realmente precisava. A metodologia só é tão boa quanto os insumos que recebe.

Picos de tokens acontecem. Encontrei uma sessão em que o Superpowers consumiu tokens agressivamente durante a fase de brainstorming, gerando um design elaborado para uma tarefa que não justificava isso. As issues do GitHub confirmam que isso não é exclusivo da minha experiência — a issue #953 no repositório descreve um padrão semelhante. É raro, mas acontece, e se você está com orçamento apertado de tokens, é bom saber disso.

A curva de aprendizado é real para equipes. Se você é um desenvolvedor solo, o Superpowers funciona imediatamente. Se pretende implementar isso em uma equipe, espere perguntas. Os companheiros visuais confundem desenvolvedores acostumados apenas ao terminal. As perguntas de esclarecimento frustram quem “só quer que ele programe”. A imposição do TDD irrita quem não escreve testes (e não está pronto para começar). A adoção exige engajamento, não só instalação.

Esses não são impeditivos. São trade-offs. E conhecê-los de antemão permite decidir se o custo-benefício faz sentido para sua situação específica.

Quando Usar o Superpowers (E Quando Deixar de Lado)

Após um mês de uso diário, este é o meu framework de decisão:

Use o Superpowers quando:

• A tarefa envolve múltiplos arquivos, serviços ou decisões arquiteturais
• Você está desenvolvendo uma funcionalidade que precisa integrar com código existente
• Os requisitos são ambíguos ou complexos o suficiente para serem mal interpretados
• Você se importa com cobertura de testes e estrutura do código, não apenas se “funciona”
• Você está estimando custos do projeto e precisa de consumo de tokens previsível
• Você trabalha em uma base de código que irá manter a longo prazo

Deixe o Superpowers de lado quando:

• Você precisa de um script ou utilitário rápido e pontual
• A tarefa é uma correção de bug simples com solução óbvia
• Você está explorando ou prototipando e não quer o overhead de planejamento
• O orçamento de tokens é extremamente apertado e a tarefa é direta

O ponto ideal — onde o Superpowers entrega mais valor por token gasto — são tarefas de média a alta complexidade em bases de código ativas e mantidas. É aí que o planejamento previne retrabalho caro, o TDD captura regressões e a arquitetura de subagentes acelera a implementação paralela.

Superpowers vs. As Alternativas: Comparação Rápida

Superpowers não é o único framework estruturado para Claude Code. Duas alternativas notáveis são o GSD (Get Stuff Done) e o gstack. Veja como eles diferem em um panorama geral:

A escolha não é “qual é o melhor” — e sim “qual se encaixa na sua tarefa”. Eu uso o Superpowers como padrão e ocasionalmente o desativo para tarefas rápidas, onde a abordagem leve do GSD é mais adequada. São ferramentas complementares, não concorrentes.

O Que Isso Significa Para Meu Trabalho Agora

Após um mês de uso, o Superpowers mudou meu fluxo de trabalho com o Claude Code de três maneiras específicas.

Primeiro, parei de tratar o Claude Code como um gerador de código e passei a vê-lo como um parceiro de desenvolvimento. As fases de esclarecimento e design forçam uma conversa que antes não existia. Meus prompts ficaram mais curtos e focados porque sei que o framework fará as perguntas de acompanhamento certas. Não tento mais colocar todos os requisitos em um único prompt.

Segundo, minha precisão na estimativa de projetos melhorou. O uso previsível de tokens significa que posso dimensionar recursos assistidos por IA com confiança. “Esse recurso vai consumir aproximadamente X tokens para ser implementado” é uma afirmação que agora posso fazer e acertar dentro de uma margem razoável. Antes do Superpowers, essa estimativa tinha uma margem de erro tão grande que caberia um caminhão.

Terceiro — e isso me surpreendeu — estou escrevendo especificações melhores. As perguntas de esclarecimento me ensinaram quais informações o agente realmente precisa, em vez do que eu incluía por hábito. Minhas especificações estão mais curtas, precisas e resultam em menos iterações. O framework me treinou tanto quanto treinou o agente.

O Superpowers é a ferramenta certa para todo mundo? Não. Se você está fazendo tarefas simples, prototipando ou trabalhando em um domínio onde o planejamento não compensa, ele vai te atrasar. Mas se você está construindo software de verdade — recursos que precisam funcionar, integrar e ser mantidos — a disciplina das cinco fases não é sobrecarga. É assim que software profissional é construído. O framework apenas reforça o que bons engenheiros já fazem e entrega isso a uma IA que precisava desesperadamente dessa estrutura.

As 121.000 estrelas no GitHub não são hype. São 121.000 desenvolvedores que bateram na mesma parede que eu — IA brilhante, zero disciplina — e encontraram a mesma resposta.

Instale. Rode na sua próxima tarefa complexa. Depois decida por si mesmo. Foi o que eu fiz, e o experimento falou mais alto do que qualquer review.

Perguntas Frequentes

O Superpowers funciona com todos os modelos do Claude Code?

O Superpowers funciona com qualquer modelo disponível no Claude Code, incluindo Opus 4.6 e Sonnet 4.6. As habilidades são independentes do modelo — elas modificam o fluxo de trabalho, não as capacidades subjacentes do modelo. As melhorias de desempenho escalam conforme a capacidade do modelo, então sessões com Opus geralmente apresentam ganhos de qualidade maiores do que sessões com Sonnet.

Como desativo o Superpowers para tarefas simples?

Prefixe seu prompt com "tarefa rápida" ou "pular planejamento" e o orquestrador normalmente ignora o ciclo completo de esclarecimento, design e planejamento. Você também pode desativar temporariamente o plugin com /plugin disable superpowers e reativá-lo com /plugin enable superpowers. Para um controle mais granular, habilidades individuais podem ser ativadas ou desativadas nas configurações do plugin.

O Superpowers entra em conflito com outros plugins ou habilidades do Claude Code?

Nos meus testes ao longo de quatro meses de uso diário, o Superpowers convive de forma limpa com outros plugins e habilidades personalizadas. O orquestrador foi projetado para reconhecer quando outra habilidade deve lidar com uma solicitação e cede espaço conforme necessário. Se você encontrar conflitos, verifique se suas outras habilidades não definem condições de gatilho que se sobrepõem às fases principais do Superpowers.

O Superpowers é gratuito?

Sim. O Superpowers é totalmente open source sob a licença MIT, hospedado em github.com/obra/superpowers. Não há planos pagos, recursos premium ou limites de uso. Todo o framework — todas as 14 habilidades — é gratuito para instalar, usar e modificar.

Quanto o Superpowers reduz o custo de tokens?

Com base no meu experimento de 12 sessões: aproximadamente 9% de redução de custo e 14% de redução de tokens em média, com as economias concentradas em tarefas médias e complexas. Tarefas simples podem até usar mais tokens devido à sobrecarga de planejamento. O dado mais valioso é a consistência — a variação no uso de tokens caiu de 2 a 3 vezes, tornando a estimativa de custos de projetos muito mais confiável.

Vamos Trabalhar Juntos

Quer construir sistemas de IA, automatizar fluxos de trabalho ou escalar sua infraestrutura tecnológica? Eu posso ajudar.

• Fiverr (soluções e integrações personalizadas): fiverr.com/s/EgxYmWD
• Portfólio: mejba.me
• Ramlit Limited (soluções corporativas): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (serviços de segurança): xcybersecurity.io