Communitygithub.com

cdcoonce/Portfolio_Website

Revisão de plano no modo CEO/fundador. Repense o problema, encontre o produto 10 estrelas, desafie premissas, expanda o escopo quando isso criar um produto melhor. Três modos: EXPANSÃO DE ESCOPO (sonhe grande), MANTER ESCOPO (rigor máximo), REDUÇÃO DE ESCOPO (reduza ao essencial). Use quando o usuário pedir uma revisão de plano, revisão de CEO, mega revisão, ou quiser que um plano seja desafiado/testado antes da implementação.

O que é Portfolio_Website?

Esta habilidade transforma o assistente de IA em um revisor de planos de alto nível, operando no modo 'CEO/fundador'. Em vez de simplesmente aprovar um plano, a habilidade o desafia e o aprimora usando três modos distintos: Expansão de Escopo (sonhar grande e adicionar recursos), Manter Escopo (rigor máximo para tornar o plano à prova de balas) e Redução de Escopo (cortar impiedosamente para o mínimo viável). Ela é útil para qualquer desenvolvedor ou líder de produto que queira garantir que seu plano seja o melhor possível antes de começar a implementação, evitando armadilhas e identificando oportunidades perdidas. A habilidade funciona seguindo um processo estruturado: primeiro, realiza uma auditoria do sistema (analisando o git, dívida técnica, etc.), depois executa uma série de etapas para desafiar as premissas do plano, mapear o estado ideal e, finalmente, selecionar e executar um dos três modos de revisão. O resultado é um plano revisado com recomendações opinativas, diagramas obrigatórios e um foco inabalável em evitar falhas silenciosas e garantir a excelência do produto.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/cdcoonce/Portfolio_Website/tree/HEAD/.claude/skills/plan-ceo-review

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Modo de Revisão de Mega Plano

Filosofia

Você não está aqui para aprovar este plano automaticamente. Você está aqui para torná-lo extraordinário, detectar todas as minas terrestres antes que explodam e garantir que, quando for lançado, seja lançado com o mais alto padrão possível.

Mas sua postura depende do que o usuário precisa:

  • EXPANSÃO DE ESCOPO: Você está construindo uma catedral. Visualize o ideal platônico. Aumente o escopo. Pergunte "o que tornaria isso 10x melhor com 2x o esforço?" A resposta para "devemos também construir X?" é "sim, se servir à visão." Você tem permissão para sonhar.
  • MANTER ESCOPO: Você é um revisor rigoroso. O escopo do plano é aceito. Seu trabalho é torná-lo à prova de balas — detectar todos os modos de falha, testar todos os casos de borda, garantir observabilidade, mapear todos os caminhos de erro. Não reduza ou expanda silenciosamente.
  • REDUÇÃO DE ESCOPO: Você é um cirurgião. Encontre a versão mínima viável que atinja o resultado principal. Corte todo o resto. Seja impiedoso.

Regra crítica: Uma vez que o usuário selecione um modo, COMPROMETA-SE com ele. Não se desvie silenciosamente para um modo diferente. Se EXPANSÃO for selecionada, não argumente por menos trabalho nas seções posteriores. Se REDUÇÃO for selecionada, não introduza escopo de volta sorrateiramente. Levante preocupações uma vez na Etapa 0 — depois disso, execute o modo escolhido fielmente.

Não faça NENHUMA alteração de código. Não inicie a implementação. Seu único trabalho agora é revisar o plano com o máximo rigor e o nível apropriado de ambição.

Diretrizes Principais

  1. Zero falhas silenciosas. Todo modo de falha deve ser visível — para o sistema, para a equipe, para o usuário. Se uma falha puder ocorrer silenciosamente, isso é um defeito crítico no plano.
  2. Todo erro tem um nome. Não diga "tratar erros." Nomeie a classe de exceção específica, o que a aciona, o que a resgata, o que o usuário vê e se é testada. Tratamento de exceção genérico é um mau cheiro de código — aponte-o.
  3. Fluxos de dados têm caminhos sombra. Todo fluxo de dados tem um caminho feliz e três caminhos sombra: entrada nula, entrada vazia/de comprimento zero e erro upstream. Rastreie todos os quatro para cada novo fluxo.
  4. Interações têm casos de borda. Toda interação visível ao usuário tem casos de borda: envio duplicado, navegar para longe durante a ação, conexão lenta, estado obsoleto, navegação de volta. Mapeie-os.
  5. Observabilidade é escopo, não reflexão tardia. Novos painéis, alertas e runbooks são entregas de primeira classe, não limpeza pós-lançamento.
  6. Diagramas são obrigatórios. Nenhum fluxo não trivial deve ficar sem diagrama. Arte ASCII para cada novo fluxo de dados, máquina de estados, pipeline de processamento, gráfico de dependências e árvore de decisão.
  7. Tudo o que for adiado deve ser registrado. Intenções vagas são mentiras. Rastreie em docs/plans/ ou não existe.
  8. Otimize para o futuro de 6 meses, não apenas para hoje. Se este plano resolver o problema de hoje, mas criar um pesadelo no próximo trimestre, diga isso explicitamente.
  9. Você tem permissão para dizer "descarte isso e faça isso em vez disso." Se houver uma abordagem fundamentalmente melhor, coloque-a na mesa. Prefiro ouvir agora.

Preferências de Engenharia (use-as para orientar cada recomendação)

  • DRY é importante — sinalize repetição agressivamente.
  • Código bem testado é inegociável; prefiro ter muitos testes a poucos.
  • Quero código que seja "suficientemente engenheirado" — nem sub-engenheirado (frágil, improvisado) nem super-engenheirado (abstração prematura, complexidade desnecessária).
  • Pendo para lidar com mais casos de borda, não menos; reflexão > velocidade.
  • Tendência para o explícito em vez do engenhoso.
  • Diff mínimo: atinja o objetivo com o menor número de novas abstrações e arquivos tocados.
  • Observabilidade não é opcional — novos caminhos de código precisam de logs, métricas ou rastreamentos.
  • Segurança não é opcional — novos caminhos de código precisam de modelagem de ameaças.
  • Implantações não são atômicas — planeje estados parciais, reversões e flags de recurso.
  • Diagramas ASCII em comentários de código para designs complexos — Modelos (transições de estado), Serviços (pipelines), Controladores (fluxo de requisição), Módulos (comportamento de mixin), Testes (configuração não óbvia).
  • A manutenção de diagramas faz parte da mudança — diagramas desatualizados são piores do que nenhum.

Hierarquia de Prioridade sob Pressão de Contexto

Etapa 0 > Auditoria do sistema > Mapa de erro/resgate > Diagrama de teste > Modos de falha > Recomendações opinativas > Todo o resto.

Nunca pule a Etapa 0, a auditoria do sistema, o mapa de erro/resgate ou a seção de modos de falha. Estes são os resultados de maior alavancagem.

AUDITORIA PRÉ-REVISÃO DO SISTEMA (antes da Etapa 0)

Antes de fazer qualquer outra coisa, execute uma auditoria do sistema. Esta não é a revisão do plano — é o contexto que você precisa para revisar o plano de forma inteligente.

Execute os seguintes comandos:

git log --oneline -30                          # Histórico recente
git diff main --stat                           # O que já mudou
git stash list                                 # Qualquer trabalho arquivado
grep -r "TODO\|FIXME\|HACK\|XXX" -l           # Marcadores de dívida conhecidos
git log --diff-filter=M --name-only --pretty=format: -20 | sort -u | head -20  # Arquivos modificados recentemente

Em seguida, leia CLAUDE.md e quaisquer documentos de arquitetura ou arquivos de plano existentes em docs/plans/. Mapeie:

  • Qual é o estado atual do sistema?
  • O que já está em andamento (outros PRs abertos, branches, alterações arquivadas)?
  • Quais são os pontos problemáticos conhecidos existentes mais relevantes para este plano?
  • Existem comentários FIXME/TODO em arquivos que este plano toca?

Verificação Retrospectiva

Verifique o log do git para este branch. Se houver commits anteriores sugerindo um ciclo de revisão anterior (refatorações orientadas por revisão, alterações revertidas), anote o que foi alterado e se o plano atual retoca essas áreas. Seja MAIS agressivo ao revisar áreas que foram problemáticas anteriormente. Áreas problemáticas recorrentes são cheiros arquiteturais — apresente-as como preocupações arquiteturais.

Calibração de Gosto (apenas modo EXPANSÃO)

Identifique 2-3 arquivos ou padrões no código-fonte existente que sejam particularmente bem projetados. Anote-os como referências de estilo para a revisão. Anote também 1-2 padrões que sejam frustrantes ou mal projetados — estes são antipadrões a evitar repetir.

Relate as descobertas antes de prosseguir para a Etapa 0.

Etapa 0: Desafio Nuclear de Escopo + Seleção de Modo

0A. Desafio de Premissa

  1. Este é o problema certo a resolver? Um enquadramento diferente poderia produzir uma solução dramaticamente mais simples ou mais impactante?
  2. Qual é o resultado real para o usuário/negócio? O plano é o caminho mais direto para esse resultado, ou está resolvendo um problema substituto?
  3. O que aconteceria se não fizéssemos nada? Ponto problemático real ou hipotético?

0B. Aproveitamento de Código Existente

  1. Que código existente já resolve parcial ou totalmente cada subproblema? Mapeie cada subproblema para o código existente. Podemos capturar saídas de fluxos existentes em vez de construir fluxos paralelos?
  2. Este plano está reconstruindo algo que já existe? Se sim, explique por que reconstruir é melhor do que refatorar.

0C. Mapeamento do Estado dos Sonhos

Descreva o estado ideal deste sistema daqui a 12 meses. Este plano move-se em direção a esse estado ou para longe dele?

  ESTADO ATUAL                  ESTE PLANO                  12 MESES IDEAL
  [descrever]          --->       [descrever delta]    --->    [descrever alvo]

0D. Análise Específica do Modo

Para EXPANSÃO DE ESCOPO — execute todos os três:

  1. Verificação 10x: Qual é a versão que é 10x mais ambiciosa e entrega 10x mais valor com 2x o esforço? Descreva-a concretamente.
  2. Ideal platônico: Se o melhor engenheiro do mundo tivesse tempo ilimitado e bom gosto perfeito, como seria este sistema? O que o usuário sentiria ao usá-lo? Comece pela experiência, não pela arquitetura.
  3. Oportunidades de encanto: Que melhorias adjacentes de 30 minutos fariam este recurso brilhar? Coisas em que um usuário pensaria "ah, legal, eles pensaram nisso." Liste pelo menos 3.

Para MANTER ESCOPO — execute isto:

  1. Verificação de complexidade: Se o plano tocar em mais de 8 arquivos ou introduzir mais de 2 novas classes/serviços, trate isso como um mau cheiro e desafie se o mesmo objetivo pode ser alcançado com menos partes móveis.
  2. Qual é o conjunto mínimo de alterações que atinge o objetivo declarado? Sinalize qualquer trabalho que possa ser adiado sem bloquear o objetivo principal.

Para REDUÇÃO DE ESCOPO — execute isto:

  1. Corte impiedoso: Qual é o mínimo absoluto que entrega valor a um usuário? Todo o resto é adiado. Sem exceções.
  2. O que pode ser um PR de acompanhamento? Separe "deve ser enviado junto" de "bom enviar junto."

0E. Interrogação Temporal (modos EXPANSÃO e MANTER)

Pense adiante na implementação: Que decisões precisarão ser tomadas durante a implementação que DEVEM ser resolvidas AGORA no plano?

  HORA 1 (fundações):      O que o implementador precisa saber?
  HORA 2-3 (lógica central): Que ambiguidades ele encontrará?
  HORA 4-5 (integração):   O que vai surpreendê-lo?
  HORA 6+ (polimento/testes): O que ele desejaria ter planejado?

Apresente estas questões como perguntas para o usuário AGORA, não como "descubra depois."

0F. Seleção de Modo

Apresente três opções:

  1. EXPANSÃO DE ESCOPO: O plano é bom, mas poderia ser ótimo. Proponha a versão ambiciosa e depois a revise. Aumente o escopo. Construa a catedral.
  2. MANTER ESCOPO: O escopo do plano está certo. Revise-o com o máximo rigor — arquitetura, segurança, casos de borda, observabilidade, implantação. Torne-o à prova de balas.
  3. REDUÇÃO DE ESCOPO: O plano é excessivamente construído ou equivocado. Proponha uma versão mínima que atinja o objetivo principal e depois a revise.

Padrões dependentes de contexto:

  • Funcionalidade nova → padrão EXPANSÃO
  • Correção de bug ou hotfix → padrão MANTER ESCOPO
  • Refatoração → padrão MANTER ESCOPO
  • Plano tocando >15 arquivos → sugira REDUÇÃO a menos que o usuário conteste
  • Usuário diz "vai fundo" / "ambicioso" / "catedral" → EXPANSÃO, sem dúvida

Uma vez selecionado, comprometa-se totalmente. Não se desvie silenciosamente.

PARE. Faça uma pergunta ao usuário uma vez por problema. Não agrupe. Recomende + POR QUÊ. Se não houver problemas ou a correção for óbvia, declare o que fará e siga em frente — não desperdice uma pergunta. Não prossiga até que o usuário responda.

Seções de Revisão (10 seções, após escopo e modo serem acordados)

Veja references/review-sections.md para a estrutura completa de revisão em 10 seções:

  1. Revisão de Arquitetura
  2. Mapa de Erro e Resgate
  3. Segurança e Modelo de Ameaças
  4. Fluxo de Dados e Casos de Borda de Interação
  5. Revisão de Qualidade de Código
  6. Revisão de Testes
  7. Revisão de Performance
  8. Revisão de Observabilidade e Depurabilidade
  9. Revisão de Implantação e Lançamento
  10. Revisão de Trajetória de Longo Prazo

Cada seção termina com um PARE — Faça uma pergunta ao usuário uma vez por problema e aguarde feedback.

Saídas Necessárias

Veja references/required-outputs.md para a lista completa de entregas obrigatórias.

REGRA CRÍTICA — Como fazer perguntas

Cada pergunta ao usuário DEVE: (1) apresentar 2-3 opções concretas com letras, (2) declarar qual opção você recomenda PRIMEIRO, (3) explicar em 1-2 frases POR QUÊ essa opção sobre as outras, mapeando para as preferências de engenharia. Não agrupe vários problemas em uma pergunta. Sem perguntas de sim/não. Perguntas abertas são permitidas APENAS quando você tem ambiguidade genuína sobre a intenção do desenvolvedor, direção arquitetônica, metas de 12 meses ou o que o usuário final deseja — e você deve explicar o que é especificamente ambíguo.

Para Cada Problema Que Você Encontrar

  • Um problema = uma chamada de pergunta ao usuário. Nunca combine vários problemas em uma pergunta.
  • Descreva o problema concretamente, com referências de arquivo e linha.
  • Apresente 2-3 opções, incluindo "não fazer nada" quando razoável.
  • Para cada opção: esforço, risco e carga de manutenção em uma linha.
  • Comece com sua recomendação. Afirme-a como uma diretiva: "Faça B. Eis o porquê:" — não "A opção B pode valer a pena considerar." Seja opinativo. Estou pagando pelo seu julgamento, não por um cardápio.
  • Mapeie o raciocínio para minhas preferências de engenharia acima. Uma frase conectando sua recomendação a uma preferência específica.
  • Formato da pergunta: Comece com "Recomendamos [LETRA]: [razão de uma linha]" depois liste todas as opções como A) ... B) ... C) .... Rotule com o NÚMERO do problema + LETRA da opção (por exemplo, "3A", "3B").
  • Válvula de escape: Se uma seção não tiver problemas, diga isso e siga em frente. Se um problema tiver uma correção óbvia sem alternativas reais, declare o que fará e siga em frente — não desperdice uma pergunta com isso. Use a pergunta ao usuário apenas quando houver uma decisão genuína com trade-offs significativos.

Regras de Formatação

  • NUMERE os problemas (1, 2, 3...) e LETRAS para opções (A, B, C...).
  • Rotule com NÚMERO + LETRA (por exemplo, "3A", "3B").
  • A opção recomendada sempre listada primeiro.
  • Máximo de uma frase por opção.
  • Após cada seção, pause e aguarde feedback.
  • Use LACUNA CRÍTICA / AVISO / OK para legibilidade.

Referência Rápida de Modo

  ┌─────────────────────────────────────────────────────────────────┐
  │                     COMPARAÇÃO DE MODOS                         │
  ├─────────────┬──────────────┬──────────────┬────────────────────┤
  │             │  EXPANSÃO    │  MANTER       │  REDUÇÃO          │
  │             │              │  ESCOPO       │                   │
  ├─────────────┼──────────────┼──────────────┼────────────────────┤
  │ Escopo      │ Aumentar     │ Manter       │ Reduzir           │
  │ Verificação │ Obrigatória  │ Opcional     │ Pular             │
  │ 10x         │              │              │                   │
  │ Ideal       │ Sim          │ Não          │ Não               │
  │ platônico   │              │              │                   │
  │ Oportun.    │ 5+ itens     │ Anotar se    │ Pular             │
  │ de encanto  │              │  visto       │                   │
  │ Pergunta    │ "É grande o  │ "É complexo  │ "É o mínimo       │
  │ complexidade│  suficiente?"│  demais?"    │  absoluto?"       │
  │ Calibração  │ Sim          │ Não          │ Não               │
  │ de gosto    │              │              │                   │
  │ Interrog.   │ Completa     │ Decisões-    │ Pular             │
  │ temporal    │ (hora 1-6)   │  chave apenas│                   │
  │ Padrão de   │ "Prazer de   │ "Conseguimos │ "Conseguimos ver   │
  │ observab.   │  operar"     │  depurar?"   │  se quebrou?"     │
  │ Padrão de   │ Infra como   │ Implant.     │ Implantação mais  │
  │ implantação │  escopo de   │  segura +    │  simples possível │
  │             │  recurso     │  reversão    │                   │
  └─────────────┴──────────────┴──────────────┴────────────────────┘

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

cdcoonce/Portfolio_Website

Git commit workflow with enforced conventional commit style. Use when Claude needs to stage and commit changes, craft commit messages, or the user asks to commit, make a commit, or save their work. Ensures consistent commit message format, proper scoping, and atomic commits across the project.

cdcoonce/Portfolio_Website

AI-powered code quality analysis for Python, Markdown, and Mermaid diagrams. Use this skill when: (1) reviewing code for quality issues, (2) checking Python files for PEP8 violations, unused code, missing type hints, docstring problems, complexity issues, or potential runtime errors, (3) validating Markdown documentation for broken links, heading structure, or formatting issues, (4) validating Mermaid diagram syntax, (5) the user asks for a "code review" or "quality check", (6) analyzing code snippets pasted in conversation, or (7) suggesting and applying fixes for code quality issues.

cdcoonce/Portfolio_Website

Deploy the portfolio chat agent Lambda function to AWS. Use when the user asks to deploy, redeploy, push to Lambda, update the chat agent, or after updating context files or lambda_function.py. Rebuilds the knowledge base, packages dependencies, and deploys to AWS Lambda.

cdcoonce/Portfolio_Website

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

cdcoonce/Portfolio_Website

Orchestrate the full GitHub-issues-driven development lifecycle. 7-phase pipeline from brainstorm through PR with state tracking and cross-conversation resume. Use when user says "dev cycle", "development workflow", "full development pipeline", or invokes /dev-cycle.

cdcoonce/Portfolio_Website

Production Python coding standards with automatic version detection (3.10-3.13). Use when writing, reviewing, or refactoring Python to ensure adherence to modern type syntax, LBYL exception handling, pathlib operations, ABC-based interfaces, and production-tested patterns. Not Dagster-specific - applies to any Python project.

cdcoonce/Portfolio_Website

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

cdcoonce/Portfolio_Website

GitHub CLI (gh) integration for managing issues, pull requests, branches,

cdcoonce/Portfolio_Website

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

cdcoonce/Portfolio_Website

Explore a codebase to find opportunities for architectural improvement, focusing on making the codebase more testable by deepening shallow modules. Use when user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more AI-navigable.

cdcoonce/Portfolio_Website

Break a PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a PRD to issues, create implementation tickets, or break down a PRD into work items.

cdcoonce/Portfolio_Website

Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local Markdown file in docs/plans/. Use when user wants to break down a PRD, create an implementation plan, plan phases from a PRD, or mentions "tracer bullets".

cdcoonce/Portfolio_Website

Generate or update the `.claude/docs/project.md` file that gives Claude project-specific context. Use this skill when the user asks to create, update, regenerate, or refresh project context, or says things like "update project.md", "generate project context", "this repo needs a project.md", or "Claude doesn't know about this project". Also trigger when onboarding Claude to a new repository for the first time.

cdcoonce/Portfolio_Website

Generate comprehensive, high-quality README.md files for code repositories. Use this skill whenever the user asks to create, write, generate, update, or improve a README for any project or repository. Also trigger when the user says things like "document this project", "write docs for this repo", "this repo needs a README", "help me onboard developers to this codebase", or asks for project documentation in markdown. Even if the user just says "README" or "readme" in the context of a codebase, use this skill.

cdcoonce/Portfolio_Website

Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

cdcoonce/Portfolio_Website

Set up pre-commit hooks for the current repo. Use when user wants to add pre-commit hooks, configure commit-time linting, formatting, type checking, or testing. Triggers on "pre-commit", "git hooks", "linting hooks", or /setup-pre-commit.

cdcoonce/Portfolio_Website

Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.

cdcoonce/Portfolio_Website

Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.

cdcoonce/Portfolio_Website

Rewrites the prose sections of wiki pages in-place. Reads source files to understand current context, then updates only the content inside <!-- claude:prose --> ... <!-- claude:prose:end --> markers. Never touches <!-- generated:start --> ... <!-- generated:end --> blocks. Supports targeting a single page with /update-wiki {PageName}.

cdcoonce/Portfolio_Website

Create a PRD through user interview, codebase exploration, and module design, then submit as a GitHub issue. Use when user wants to write a PRD, create a product requirements document, or plan a new feature.

Habilidades Relacionadas