@pixeleducacao/curso-openclaw 2026.5.8

package/assets/skills/planejamento/brainstorming/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: brainstorming
+status: ATIVO
+category: planejamento
+owner: aluno
+version: 1.0
+mode: guided
+estimated_time: 5-15min (varia por escopo da decisão)
+model_compatible: [gpt-5, gpt-5.5, claude-sonnet-4, claude-opus-4]
+description: Use BEFORE any creative or design work — features novas, mudanças de comportamento do agente, decisões de arquitetura. Explores user intent, requirements, and design BEFORE implementation. Adapted from obra/superpowers (originally for software engineering, applied here to general agent workflows). Forces explicit thinking instead of jumping to action.
+source: https://github.com/obra/superpowers (skill: brainstorming)
+---
+
+# Brainstorming — Pensar Antes de Construir
+
+## Promessa
+
+Antes de pedir pro agente CONSTRUIR algo (feature nova, fluxo, automação, conteúdo), gastar 5-15min explorando o problema. Resultado: você sabe O QUE quer e POR QUÊ antes de começar. Constrói a coisa certa em vez de iterar versões erradas.
+
+Adaptado da skill `brainstorming` do projeto [obra/superpowers](https://github.com/obra/superpowers) — originalmente pra eng de software, aplicado aqui pra workflows gerais de agente.
+
+## Quando usar
+
+**Use ANTES de:**
+- Pedir agente criar skill nova
+- Definir comportamento novo (ex: "agente vai responder X de jeito Y")
+- Adicionar integração nova
+- Mudar fluxo existente que tá te incomodando
+- Qualquer "vamos construir" que envolve >1 hora de trabalho
+
+**NÃO use pra:**
+- Tarefa simples ("escreve um post sobre X")
+- Bug fix óbvio
+- Pedidos one-shot sem peso futuro
+
+## Como funciona
+
+### Etapa 1 — Por que (5min)
+
+Antes de QUALQUER decisão técnica, responde:
+
+```
+1. O que tá te incomodando hoje?
+2. Como você sabe que isso é problema (sintomas concretos)?
+3. Se você não fizer NADA, qual o impacto em 30 dias?
+4. Quem mais tem esse problema? (você só? equipe? clientes?)
+```
+
+Se você não consegue responder os 4 com clareza, você não tem PROBLEMA — você tem URGE de fazer coisa nova. Pausa.
+
+### Etapa 2 — O quê (5min)
+
+```
+1. Em 1 frase, qual o resultado ideal? (não "usar X tecnologia" — RESULTADO)
+2. Como você vai saber que deu certo? (métrica concreta)
+3. Mínima coisa que resolve o problema? (não a versão completa, a versão MÍNIMA)
+```
+
+Maior parte dos projetos morrem porque pulam essa etapa. Aluno define escopo em "tudo que parece interessante" em vez de "o mínimo que resolve".
+
+### Etapa 3 — Como (5min)
+
+Só agora, pensa em implementação:
+
+```
+1. 2-3 abordagens diferentes pra resolver
+2. Tradeoff principal de cada uma (tempo vs qualidade vs flexibilidade)
+3. Qual você escolhe e POR QUÊ?
+```
+
+Se aluno só consegue pensar em 1 abordagem, geralmente não pensou direito. Forçar 2-3 expõe alternativas.
+
+### Etapa 4 — Riscos (3min)
+
+```
+1. O que pode dar errado?
+2. Se isso acontecer, qual o plano B?
+3. Custo de errar (tempo perdido, dinheiro, relacionamento)?
+```
+
+## Como invocar com seu agente
+
+Manda no chat:
+
+```
+"Vamos brainstormar [coisa que você quer]. Roda a skill brainstorming.
+
+Contexto:
+- [contexto relevante]
+
+Me guia pelas 4 etapas."
+```
+
+Agente vai te conduzir pelas 4 etapas com perguntas específicas pro seu caso.
+
+## Output esperado
+
+Ao final, agente entrega:
+
+- **Problema** (1 parágrafo)
+- **Solução proposta** (mínima viável)
+- **Métricas de sucesso** (como saberá que funcionou)
+- **Riscos principais + mitigação**
+- **Próximos passos concretos** (não "explorar mais" — ações específicas)
+
+Salvar em `memory/decisoes/{YYYY-MM}.md` (Princípio: tudo que importa vai pra arquivo).
+
+## Adaptação pro Starter Kit
+
+A versão original da `obra/superpowers` é mais densa (15+ tópicos cobertos). Esta versão simplifica pras 4 etapas críticas. Conforme aluno usa, pode expandir pra cobertura completa do superpower original.
+
+Se quer versão completa, ler: https://github.com/obra/superpowers/blob/main/skills/brainstorming/SKILL.md
+
+## Princípios herdados
+
+- **Princípio 7 (em dúvida, perguntar):** brainstorming É a aplicação canônica desse princípio.
+- **Princípio 9 (parar se algo der errado):** se etapa 1 não consegue responder com clareza, parar e pensar mais antes de seguir.
+
+## Critérios de sucesso
+
+- [ ] As 4 etapas foram percorridas explicitamente (não pulou nenhuma)
+- [ ] Solução proposta é MÍNIMA (não "tudo de uma vez")
+- [ ] Output salvo em `memory/decisoes/`
+- [ ] Próximos passos são concretos (verbos no infinitivo + prazos)
+
+## Referências
+
+- Skill original: https://github.com/obra/superpowers
+- Princípios universais: [`../../starter/onboarding-checklist/references/principios-defensivos.md`](../../starter/onboarding-checklist/references/principios-defensivos.md)
+
+## Status
+
+✅ ATIVO desde v1 do Starter Kit (02/05/2026) — versão curada/simplificada do superpower original.

package/assets/skills/planejamento/executing-plans/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: executing-plans
+status: ATIVO
+category: planejamento
+owner: aluno
+version: 1.0
+mode: guided
+estimated_time: varia (executa o plano todo)
+model_compatible: [gpt-5, gpt-5.5, claude-sonnet-4, claude-opus-4]
+description: Use to execute a plan written by writing-plans skill. Walks through tasks one by one, marks progress in real-time, surfaces blockers, asks for review at checkpoints. Adapted from obra/superpowers (executing-plans skill). Loops independently until plan is done or blocker hit.
+source: https://github.com/obra/superpowers (skill: executing-plans)
+---
+
+# Executing Plans — Tirar Plano do Papel
+
+## Promessa
+
+Pega o `PLAN.md` (gerado pela skill `writing-plans`) e executa tarefa por tarefa. Atualiza estado em tempo real, narra progresso, para em checkpoints definidos pra você revisar.
+
+Sem essa skill, agente é "responsivo" — só faz quando você pergunta. Com ela, agente é "executivo" — você dá o plano, ele toca.
+
+Adaptado de [obra/superpowers](https://github.com/obra/superpowers).
+
+## Quando usar
+
+**Use quando:**
+- Tem `PLAN.md` em `memory/projects/{nome}/`
+- Plano tem tarefas atômicas com verificação
+- Você tem ~30min+ pra deixar agente executar e revisar pontos de checkpoint
+
+**NÃO use pra:**
+- Plano vago ("vou começar a fazer X")
+- Tarefas sem critério de verificação (agente não saberá quando termina)
+- Decisões pendentes ainda
+
+## Como invocar
+
+```
+"Roda executing-plans pro projeto {nome}.
+
+PLAN.md em memory/projects/{nome}/PLAN.md.
+
+Quero que execute até o checkpoint da fase 1."
+```
+
+Ou mais aberto:
+
+```
+"Executa PLAN.md de memory/projects/{nome}/. Para no primeiro
+checkpoint pra eu revisar."
+```
+
+## Comportamento esperado do agente
+
+### 1. Lê plano + estado
+
+Antes de começar, lê `PLAN.md` inteiro pra entender:
+
+- O que tá feito (`[x]`)
+- O que tá em progresso (`[~]`)
+- O que tá bloqueado (`[!]`)
+- O que falta (`[ ]`)
+
+Identifica próxima tarefa não-bloqueada.
+
+### 2. Anuncia próxima tarefa
+
+```
+"Próxima: T1.2 — {descrição}.
+Estimativa: {Xmin}.
+Verificação: {critério}.
+
+Vou começar?"
+```
+
+Espera OK do aluno (ou pula confirmação se aluno mandou "executa tudo").
+
+### 3. Executa
+
+Faz a tarefa. Narra etapas significativas (não cada operação granular).
+
+Se encontrar problema:
+- **Ambíguo (precisa decisão):** PARA, pergunta ao aluno (Princípio 7)
+- **Bloqueado externo (depende de algo fora):** marca `[!]`, segue pra próxima tarefa não-bloqueada
+- **Erro técnico:** investiga 1-2x, se não resolve PARA e reporta (Princípio 9)
+
+### 4. Verifica resultado
+
+Antes de marcar `[x]`, valida o critério explicitamente:
+
+```
+"Verificação T1.2: {critério}
+Resultado: {evidência concreta}
+Status: ✓ passou"
+```
+
+Sem evidência concreta, NÃO marca como feito (Princípio: provar que funciona antes de declarar pronto).
+
+### 5. Atualiza PLAN.md
+
+Edita `PLAN.md` em tempo real:
+
+- `[ ]` → `[~]` (começou)
+- `[~]` → `[x]` (terminou e verificou)
+- `[ ]` → `[!]` (bloqueado, com nota)
+
+Atualiza seção "Estado atual" com última atividade.
+
+### 6. Checkpoints
+
+Em checkpoints definidos no plano (ex: fim de cada fase), PARA e mostra ao aluno:
+
+```
+"Checkpoint Fase 1 ✓
+
+Resumo do que rolou:
+- T1.1 [x]: {descrição curta + resultado}
+- T1.2 [x]: {idem}
+- T1.3 [x]: {idem}
+
+Tempo gasto: ~Xmin (estimativa: Ymin)
+Aprendizados: {nota se aprendeu algo importante}
+
+Pronto pra Fase 2 ou quer revisar algo?"
+```
+
+Espera OK pra seguir.
+
+## Casos especiais
+
+### Aluno pediu "executa só T1.2"
+
+Executa SÓ aquela tarefa. Não avança automaticamente.
+
+### Aluno pediu "executa tudo até o final"
+
+Executa todas as fases. Para SÓ em blockers ou quando precisa de decisão. Reporta ao final.
+
+### Aluno pediu "para por aqui"
+
+Pausa execução. Salva estado em `PLAN.md`. Não modifica nada mais.
+
+### Plano tem tarefa com perigo (deletar dados, push pra prod, etc)
+
+SEMPRE confirma antes — independente de aluno ter pedido "executa tudo". Princípio 2 (confirmação) sobrepõe modo automático.
+
+## Princípios herdados
+
+- **Princípio 4 (narrar antes):** sempre anuncia próxima tarefa antes de executar.
+- **Princípio 5 (atualizar estado):** PLAN.md atualizado em tempo real.
+- **Princípio 7 (em dúvida, perguntar):** ambiguidade material → para e pergunta.
+- **Princípio 9 (parar se algo der errado):** erros técnicos não resolvidos em 1-2 tentativas viram pausa.
+
+## Critérios de sucesso
+
+- [ ] Próxima tarefa identificada e anunciada
+- [ ] Tarefa executada
+- [ ] Verificação explícita rodada (com evidência)
+- [ ] PLAN.md atualizado
+- [ ] Checkpoint reportado ao aluno (se aplicável)
+
+## Erros comuns
+
+- **Marcar tarefa como `[x]` sem verificação concreta:** falha clássica. Mostra evidência (output do comando, screenshot, link) ou não marca.
+- **Pular tarefa "porque parecia trivial":** todas as tarefas viram `[x]` ou `[!]` ou `[~]`. Nenhuma é silenciosamente pulada.
+- **Continuar mesmo com bloqueador:** Princípio 9 manda parar e replanejar, não empurrar.
+
+## Adaptação pro Starter Kit
+
+Versão original do superpower é mais elaborada (gerencia branches git, testes automáticos, etc). Esta versão simplifica pra projetos típicos de aluno: workflows, integrações, conteúdo.
+
+Versão completa: https://github.com/obra/superpowers/blob/main/skills/executing-plans/SKILL.md
+
+## Referências
+
+- Skill original: https://github.com/obra/superpowers
+- Skill complementar: `writing-plans` (cria o plano)
+- Skill complementar: `verification-before-completion` (valida ao final)
+
+## Status
+
+✅ ATIVO desde v1 do Starter Kit (02/05/2026) — versão curada/simplificada do superpower original.

package/assets/skills/planejamento/verification-before-completion/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: verification-before-completion
+status: ATIVO
+category: planejamento
+owner: aluno
+version: 1.0
+mode: guided
+estimated_time: 5-15min (depende do escopo)
+model_compatible: [gpt-5, gpt-5.5, claude-sonnet-4, claude-opus-4]
+description: Use BEFORE declaring task/project complete. Forces evidence-based verification — runs tests, checks output, confirms each success criterion before marking done. Adapted from obra/superpowers (verification-before-completion skill). Eliminates "I think it works" claims.
+source: https://github.com/obra/superpowers (skill: verification-before-completion)
+---
+
+# Verification Before Completion — Provar Antes de Declarar
+
+## Promessa
+
+Antes de declarar "tá pronto" / "merge" / "publica" / "tá ok", roda verificação concreta de cada critério de sucesso. Sem evidência, não marca como feito.
+
+Mata o "achei que funcionava" e força "comprovei que funciona".
+
+Adaptado de [obra/superpowers](https://github.com/obra/superpowers).
+
+## Quando usar
+
+**Use ANTES de:**
+- Marcar projeto/plano como completo
+- Fechar issue
+- Publicar conteúdo
+- Lançar feature
+- Mandar entregável pro cliente
+- Encerrar wave/sprint
+
+**Use SEMPRE em:**
+- Última tarefa do `executing-plans`
+- Final do `wizard-{qualquer}` que afirma sucesso
+- Antes de declarar bug "resolvido"
+
+## Como funciona
+
+### 1. Lê critérios de sucesso
+
+Onde estão:
+- `PLAN.md` → seção "Sucesso = (critérios)"
+- Issue/ticket → critérios definidos
+- Brief de conteúdo → critérios de qualidade
+- (Se não tem critério, **PARA** — sem critério não há verificação)
+
+### 2. Pra cada critério, confirma com evidência
+
+| Critério | Como verificar |
+|---|---|
+| "Funciona em produção" | Roda comando real, mostra output |
+| "Aparece corretamente em mobile" | Screenshot do mobile, não desktop |
+| "API retorna 200" | curl real, não "deve retornar" |
+| "Conteúdo segue brand voice" | Lê tom de voz + compara com draft |
+| "Aluno consegue completar fluxo X" | Testa o fluxo end-to-end |
+| "Aluno autorizou Y" | Mensagem do aluno mandada |
+
+**Evidência ≠ pergunta retórica.** "Acho que tá ok?" não é evidência. "Rodei `curl` e vi 200" é evidência.
+
+### 3. Reporta resultado
+
+```
+Verificação de {projeto/tarefa}:
+
+✓ Critério 1: {evidência concreta}
+✓ Critério 2: {evidência concreta}
+✗ Critério 3: {falhou — detalhe do problema}
+✓ Critério 4: {evidência}
+
+Status: 3/4 passaram. Critério 3 precisa ser resolvido antes de marcar como completo.
+
+Próxima ação: {ação concreta pra resolver critério 3}
+```
+
+### 4. SE algum critério falhou — NÃO MARCA COMO COMPLETO
+
+```
+Não vou marcar isso como completo até critério 3 passar.
+
+Opções:
+a) Resolvo critério 3 agora ({Xmin estimado})
+b) Reescala o critério (era ambicioso demais? muda?)
+c) Marca como "completo com ressalva" e abre issue pra T-X resolver isso
+
+Qual prefere?
+```
+
+NÃO permite "ah deixa, depois eu vejo" — é por isso que essa skill existe.
+
+## Erro principal que essa skill resolve
+
+```
+❌ ANTES:
+"Implementei o fluxo X."
+[marca como done]
+[3 dias depois descobre que crashou na produção em caso edge]
+
+✓ COM ESSA SKILL:
+"Implementei o fluxo X. Verificação:
+ ✓ Caminho feliz: rodei manualmente, funcionou
+ ✓ Caso edge 1 (input vazio): tratei, validei
+ ✗ Caso edge 2 (input gigante >1MB): não testei
+ 
+Não vou marcar como completo até validar caso 2.
+Vou rodar com input de 5MB agora."
+```
+
+## Princípios herdados
+
+- **Princípio 5 (atualizar estado):** verificação atualiza PLAN.md/MEMORY com resultado.
+- **Princípio 7 (em dúvida, perguntar):** se critério é ambíguo, pergunta antes de declarar OK.
+- **Princípio 8 (logging):** verificação completa vira entrada em `memory/decisoes/`.
+- **Princípio 9 (parar se algo der errado):** critério que falha = pausa, não empurra.
+
+## Como invocar
+
+No final de qualquer projeto/feature/conteúdo:
+
+```
+"Roda verification-before-completion pra: {projeto/tarefa}.
+Critérios em: {PLAN.md / brief / issue}.
+Não marca como done até passar tudo."
+```
+
+Agente vai rodar checks, mostrar evidência, reportar.
+
+## Adaptação pro Starter Kit
+
+Versão original do superpower é mais agressiva (assume contexto de software/CI). Esta versão adapta pro mix de projetos típicos de aluno: conteúdo, integrações, automações, decisões.
+
+Princípio central preservado: **evidência antes de declaração**.
+
+Versão completa: https://github.com/obra/superpowers/blob/main/skills/verification-before-completion/SKILL.md
+
+## Critérios de sucesso (meta — pra própria skill)
+
+- [ ] Lista de critérios foi extraída antes de começar (não inventada na hora)
+- [ ] Cada critério tem evidência concreta documentada
+- [ ] Critérios falhos foram reportados, não escondidos
+- [ ] Decisão final (completo / parcial / pendente) foi explícita
+
+## Erros comuns
+
+- **Confiar em "vibe check":** "parece bom" não é verificação. Roda o teste, não confia no olhómetro.
+- **Pular critérios que parecem triviais:** "verificar permissão" não é trivial até testar.
+- **Aceitar "vou validar depois":** depois é nunca. Valida agora ou marca como pendente.
+
+## Referências
+
+- Skill original: https://github.com/obra/superpowers
+- Skills complementares: `writing-plans`, `executing-plans` (cria os critérios que essa skill verifica)
+
+## Status
+
+✅ ATIVO desde v1 do Starter Kit (02/05/2026) — versão curada/simplificada do superpower original.

package/assets/skills/planejamento/writing-plans/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: writing-plans
+status: ATIVO
+category: planejamento
+owner: aluno
+version: 1.0
+mode: guided
+estimated_time: 10-30min (varia por complexidade)
+model_compatible: [gpt-5, gpt-5.5, claude-sonnet-4, claude-opus-4]
+description: Use AFTER brainstorming, BEFORE coding/building. Transforms a brainstorm output into an executable plan with concrete tasks, dependencies, and verification criteria. Adapted from obra/superpowers (writing-plans skill). Plans are documents, not chat — they survive sessions and let agent loop independently.
+source: https://github.com/obra/superpowers (skill: writing-plans)
+---
+
+# Writing Plans — Plano Executável Antes de Começar
+
+## Promessa
+
+Pega a saída do brainstorming (problema + solução proposta) e transforma em PLANO EXECUTÁVEL: tarefas concretas, dependências mapeadas, critérios de sucesso por etapa.
+
+Plano vira ARQUIVO no workspace (`memory/projects/{nome}/PLAN.md`). Sobrevive sessões. Agente lê e executa sem precisar de hand-holding.
+
+Adaptado de [obra/superpowers](https://github.com/obra/superpowers) — originalmente pra software, aplicável a qualquer projeto multi-etapa.
+
+## Quando usar
+
+**Use APÓS brainstorming, ANTES de:**
+- Construir feature nova de skill
+- Implementar workflow complexo (3+ etapas)
+- Migração de algo existente
+- Lançamento (produto, conteúdo, evento)
+
+**NÃO use pra:**
+- Tarefa one-shot sem etapas
+- Decisão pontual (vai pra `memory/decisoes/`, não plan)
+
+## Estrutura do plano
+
+```markdown
+# Plano: {Nome do projeto}
+
+> Criado em {data}. Status: {planejamento|execução|completo|pausado}.
+
+## Objetivo
+
+(1 parágrafo. Resultado concreto que você quer alcançar.
+ Não "usar tecnologia X" — RESULTADO.)
+
+## Sucesso = (critérios verificáveis)
+
+- [ ] {critério 1 — concreto, mensurável}
+- [ ] {critério 2}
+- [ ] {critério 3}
+
+## Tarefas
+
+### Fase 1: {nome}
+
+- [ ] **T1.1** — {descrição}
+  - Verificação: {como vai saber que terminou}
+  - Estimativa: {Xmin/h}
+  - Depende de: nenhuma
+
+- [ ] **T1.2** — {descrição}
+  - Verificação: ...
+  - Estimativa: ...
+  - Depende de: T1.1
+
+### Fase 2: {nome}
+
+- [ ] **T2.1** — ...
+
+## Dependências externas
+
+- {API, serviço, pessoa que precisa fazer algo antes}
+
+## Riscos
+
+- {risco 1} — mitigação: {como evitar/reagir}
+
+## Estado atual
+
+(Atualizado conforme execução. Lista o que tá feito, em progresso, bloqueado.)
+
+---
+
+*Atualizar este arquivo conforme execução. Não criar arquivo novo — versionar este.*
+```
+
+## Como invocar
+
+Manda no chat:
+
+```
+"Roda writing-plans pra: {projeto}.
+
+Brainstorming já feito (em memory/decisoes/{data}.md).
+
+Quero plano executável."
+```
+
+Agente vai:
+
+1. Ler o brainstorming
+2. Te perguntar 3-5 coisas pra refinar (escopo, prazo, recursos)
+3. Gerar plano seguindo template acima
+4. Salvar em `memory/projects/{nome}/PLAN.md`
+
+## Princípios do plano
+
+### 1. Tarefas atômicas
+
+Cada T deve ser executável em <2h. Se não cabe em 2h, quebra em sub-tarefas.
+
+❌ "Configurar integração Notion completa"  (muito amplo)
+✅ "Configurar Notion API token + validar com call de teste"
+✅ "Criar mapeamento de campos USER.md → propriedades do database Notion"
+✅ "Implementar sync bidirecional (Notion → workspace + workspace → Notion)"
+
+### 2. Verificação por tarefa
+
+Cada T tem critério de "como sei que terminou". Sem isso, agente não sabe quando parar/seguir.
+
+❌ "Implementar X"  (quando termina?)
+✅ "Implementar X até que `curl /api/x` retorne 200 com JSON esperado"
+
+### 3. Dependências mapeadas
+
+Mostrar T1.2 depende de T1.1 evita execução paralela quebrada.
+
+### 4. Estimativa honesta
+
+Se você acha que vai dar 2h, escreve 4h. Sempre escala 2x. Se errar pouco, melhor que estourar.
+
+### 5. Estado vivo
+
+Plano não é doc estático. É arquivo VIVO. Conforme executa, atualiza:
+
+- `[ ]` → `[x]` quando termina
+- `[ ]` → `[~]` quando começou mas não terminou
+- `[ ]` → `[!]` quando bloqueado (com nota explicando)
+- Adicionar T descobertas mid-execução (não esconder escopo)
+
+## Adaptação pro Starter Kit
+
+A versão original do superpower é mais detalhada (especificação de testes, refactors, etc). Esta versão simplifica pra projetos que aluno típico de starter-kit faz: launches, integrações, configs complexas.
+
+Se quer versão completa: https://github.com/obra/superpowers/blob/main/skills/writing-plans/SKILL.md
+
+## Princípios herdados
+
+- **Princípio 5 (atualizar estado):** PLAN.md é arquivo vivo, atualiza durante execução.
+- **Princípio 8 (logging):** decisões importantes do plano vão em `memory/decisoes/`.
+
+## Critérios de sucesso
+
+- [ ] Plano salvo em `memory/projects/{nome}/PLAN.md`
+- [ ] Tarefas são atômicas (cada uma <2h)
+- [ ] Cada tarefa tem critério de verificação
+- [ ] Dependências entre tarefas estão mapeadas
+- [ ] Aluno sabe a próxima ação concreta
+
+## Referências
+
+- Skill original: https://github.com/obra/superpowers
+- Skill complementar: `executing-plans` (executa o plano)
+- Skill complementar: `verification-before-completion` (valida que terminou)
+
+## Status
+
+✅ ATIVO desde v1 do Starter Kit (02/05/2026) — versão curada/simplificada do superpower original.