Communitygithub.com

Grill Me – Compreensão Compartilhada por Interrogação Sistemáti…

Entreviste o usuário implacavelmente sobre um plano ou design até alcançar compreensão mútua, resolvendo cada ramo da árvore de decisão. Use quando o usuário quiser estressar um plano, ser questionado sobre seu design ou mencionar 'me grille'.

O que é Grill Me – Compreensão Compartilhada por Interrogação Sistemáti…?

Este skill transforma o agente em um interrogador sistemático que constrói entendimento compartilhado com o usuário sobre planos e designs. Ele segue oito diretrizes primordiais: usar exclusivamente a ferramenta AskUserQuestion para todas as perguntas, agrupar até 4 questões relacionadas por domínio de interrogação, sempre recomendar uma opção principal marcada com '(Recommended)', explorar o código antes de perguntar, resolver dependências na ordem correta, manter um registro estruturado de decisões em formato de tabela, não deixar nenhuma suposição implícita sem verificação explícita, e manter as perguntas concretas sobre comportamentos, fluxos de dados e resultados visíveis ao usuário. O processo começa com a leitura silenciosa do plano, do repositório e de arquivos de convenção (project.md, CLAUDE.md), seguido de um resumo que o usuário confirma ou corrige. Em seguida, percorre domínios de interrogação predefinidos (referenciados em references/interrogation-domains.md), agrupando perguntas em lotes e registrando cada decisão em uma tabela. Domínios irrelevantes são pulados. O skill suporta opções de pré-visualização para comparação visual de artefatos concretos (código, diagramas, schemas). Quando a ferramenta AskUserQuestion não está disponível, um formato de texto de fallback é usado. A interrogação termina quando todos os domínios relevantes foram cobertos, todas as decisões resolvidas ou adiadas explicitamente, e o usuário confirma o entendimento compartilhado.

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

Perguntar na sua IA favorita

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

Documentação

Grill Me – Compreensão Compartilhada Através de Interrogação Sistemática

Filosofia

O objetivo da 'grillagem' é construir compreensão compartilhada entre o agente e o usuário. Todo plano contém suposições implícitas, restrições não declaradas e decisões ambíguas. A grillagem percorre cada ramo da árvore de decisão, um por um, até que ambas as partes estejam totalmente alinhadas.

O objetivo é zero suposições não examinadas antes do início da implementação.

Diretrizes Primordiais

  1. Use AskUserQuestion para cada pergunta. Todas as perguntas de interrogação devem passar pela ferramenta AskUserQuestion. Nunca emita uma pergunta como texto simples.
  2. Agrupe dentro de domínios. Agrupe até 4 perguntas relacionadas dentro do mesmo domínio de interrogação em uma única chamada AskUserQuestion. Nunca misture perguntas de domínios diferentes em uma única chamada.
  3. Lide com sua recomendação. Sua resposta recomendada é sempre a primeira opção, com (Recommended) anexado ao rótulo.
  4. Explore antes de perguntar. Se uma pergunta puder ser respondida lendo o código, lendo a documentação ou verificando padrões existentes — faça isso em vez de perguntar. Pergunte ao usuário apenas sobre decisões que exigem seu julgamento.
  5. Resolva dependências em ordem. Algumas decisões dependem de outras. Identifique a cadeia de dependências e resolva as decisões a montante primeiro.
  6. Registre tudo com registros estruturados. Mantenha um registro de decisões como uma tabela estruturada. Para cada pergunta resolvida, registre: domínio, tópico (cabeçalho), rótulo da opção selecionada e qualquer texto personalizado se 'Outro' foi escolhido. Apresente o registro no contexto da conversa — sem I/O de arquivo.
  7. Nenhuma suposição sobrevive. Se algo está implícito mas não declarado, traga à tona. Se algo parece óbvio, confirme. Compreensão compartilhada significa acordo explícito, não silêncio confortável.
  8. Mantenha-se concreto. Enquadre as perguntas em torno de comportamentos específicos, fluxos de dados e resultados visíveis ao usuário — não conceitos abstratos.

Configuração Pré-Interrogação

Antes de fazer qualquer pergunta, construa contexto silenciosamente:

  1. Leia o plano ou documento de design que o usuário deseja que seja grilled
  2. Explore o repositório em busca de padrões existentes, restrições e código relevante
  3. Verifique o histórico recente do git para contexto sobre o trabalho atual
  4. Leia project.md e CLAUDE.md para convenções do projeto

Em seguida, apresente um breve resumo do que você entende até agora, organizado pelos domínios de interrogação. Isso dá ao usuário a chance de corrigir grandes mal-entendidos antes de mergulhar na sondagem ramo a ramo.

Domínios de Interrogação

Trabalhe através dos domínios definidos em references/interrogation-domains.md. Adapte a ordem ao plano — comece com o domínio mais central ao que está sendo construído e vá para fora. Pule domínios que são claramente irrelevantes.

Processo de Interrogação

1. Leia e resuma seu entendimento do plano
2. O usuário confirma ou corrige o resumo
3. Para cada domínio de interrogação (ordenado por relevância):
   a. Identifique todos os pontos de decisão e suposições neste domínio
   b. Agrupe pontos de decisão relacionados em lotes de até 4 perguntas
   c. Para cada lote, invoque uma única chamada AskUserQuestion
      (recomendação primeiro para cada pergunta). Registre todas as opções selecionadas.
   d. Após resolver todos os pontos em um domínio, resuma as decisões tomadas
      Apresente as decisões do domínio como linhas no formato de tabela estruturada.
4. Após todos os domínios serem cobertos:
   - Apresente o registro completo de decisões como uma tabela estruturada:
     | # | Domínio | Tópico | Decisão | Notas |
     |---|---------|--------|---------|-------|
     | 1 | Intenção | Meta  | Outro | Dashboard interno para equipe de operações, não voltado para clientes |
   - Sinalize quaisquer itens não resolvidos ou adiados
   - Pergunte se algum domínio precisa ser revisitado

Formato da Pergunta

Toda pergunta DEVE ser feita através da ferramenta AskUserQuestion. Estruture cada chamada da seguinte forma:

{
  "question": "Quando a API do Oura retorna um 429, como devemos lidar com a limitação de taxa?",
  "header": "Limites",
  "options": [
    {
      "label": "Backoff exponencial (Recommended)",
      "description": "Repetir com backoff exponencial (1s, 2s, 4s). Lida com limites transitórios graciosamente e corresponde ao padrão de repetição já usado em src/api_client.py."
    },
    {
      "label": "Enfileirar para próxima execução",
      "description": "Pular a solicitação e adicioná-la à próxima execução programada. Mais simples, mas atrasa os dados em um ciclo."
    }
  ],
  "multiSelect": false
}

Depende de: Indique quaisquer decisões anteriores nas quais esta se baseia no texto da pergunta, ou anote "Sem dependências" se for independente.

Exemplo de perguntas em lote

{
  "questions": [
    {
      "question": "Qual é o alvo principal de implantação?",
      "header": "Implantação",
      "options": [
        {
          "label": "Docker + ECS (Recommended)",
          "description": "Corresponde à infraestrutura existente. O pipeline de implantação já existe."
        },
        {
          "label": "Kubernetes",
          "description": "Mais flexível, mas requer nova configuração de infraestrutura."
        },
        {
          "label": "Serverless",
          "description": "Menor carga operacional, mas preocupações com latência de inicialização a frio."
        }
      ],
      "multiSelect": false
    },
    {
      "question": "Quais abordagens de monitoramento devemos incluir?",
      "header": "Monitoramento",
      "options": [
        {
          "label": "Registro estruturado (Recommended)",
          "description": "Logs JSON no CloudWatch. Pesquisáveis e alertáveis."
        },
        {
          "label": "Rastreamento APM",
          "description": "Rastreamento distribuído para visibilidade do fluxo de solicitações."
        },
        {
          "label": "Métricas personalizadas",
          "description": "Contadores e medidores específicos de negócio no Datadog."
        }
      ],
      "multiSelect": true
    }
  ]
}

Usando pré-visualizações

Use o campo preview nas opções quando o usuário precisar comparar visualmente artefatos concretos — trechos de código, diagramas de arquitetura, formatos de esquema ou exemplos de configuração. O conteúdo da pré-visualização é renderizado como markdown em uma caixa monoespaçada com comparação lado a lado.

Quando usar pré-visualizações:

  • Comparar dois padrões de código ou implementações
  • Mostrar diferentes formatos de esquema ou estruturas de dados
  • Apresentar alternativas de arquitetura com diagramas ASCII

Restrição: Pré-visualizações são apenas de seleção única (multiSelect: false). Se precisar de seleção múltipla, omita pré-visualizações e use descrições.

Exemplo com pré-visualizações:

{
  "question": "Qual padrão devemos usar para o pipeline de dados?",
  "header": "Pipeline",
  "options": [
    {
      "label": "Pipeline gerador (Recommended)",
      "description": "Avaliação preguiçosa, eficiente em memória para grandes conjuntos de dados.",
      "preview": "def pipeline(source):\n    for record in source:\n        cleaned = clean(record)\n        validated = validate(cleaned)\n        yield validated"
    },
    {
      "label": "Pipeline em lote",
      "description": "Processa todos os registros de uma vez. Mais simples, mas maior uso de memória.",
      "preview": "def pipeline(source):\n    records = list(source)\n    cleaned = [clean(r) for r in records]\n    validated = [validate(r) for r in cleaned]\n    return validated"
    }
  ],
  "multiSelect": false
}

Regras para Fazer Perguntas

  • Use AskUserQuestion para cada pergunta. Ponto final.
  • Primeira opção = recomendação. A primeira opção sempre tem (Recommended) no rótulo.
  • Agrupe perguntas relacionadas. Agrupe até 4 perguntas relacionadas do mesmo domínio em uma chamada AskUserQuestion. Perguntas de domínios diferentes devem ser chamadas separadas.
  • Respeite as restrições da ferramenta. 2-4 opções por pergunta. Cabeçalhos com no máximo 12 caracteres. Use multiSelect: true quando as opções não são mutuamente exclusivas (por exemplo, 'Quais abordagens de teste devemos usar?' ou 'Quais domínios precisam de cobertura?').
  • Filtre opções. Quando houver mais de 4 escolhas válidas, apresente as 3 mais relevantes com base no contexto do repositório. Os usuários selecionam "Outro" para qualquer coisa não listada.
  • Seja específico. "Como devemos lidar com erros?" é muito vago. "Quando a API do Oura retorna um 429, devemos repetir com backoff ou enfileirar para a próxima execução?" é específico.
  • Mostre seu trabalho. Se sua recomendação for baseada em algo que você encontrou no repositório, faça referência ao arquivo e linha.
  • Aceite a resposta. Quando o usuário decidir, registre e siga em frente. Não reabra discussão a menos que uma decisão posterior crie conflito com uma anterior.

Fallback (sem AskUserQuestion disponível)

Se AskUserQuestion não estiver disponível no ambiente de execução, recorra a este formato de texto:

[Cabeçalho] — [Tópico]

[Declaração clara da pergunta]

Recomendado: [Sua recomendação e porquê]

Alternativas:

  • (A) [Opção] — [Troca]
  • (B) [Opção] — [Troca]

Quando Parar

A grillagem está completa quando:

  • Cada domínio de interrogação relevante foi coberto
  • Todos os ramos de decisão foram resolvidos ou explicitamente adiados
  • O usuário confirma compreensão compartilhada

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

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

CEO/founder-mode plan review. Rethink the problem, find the 10-star product, challenge premises, expand scope when it creates a better product. Three modes: SCOPE EXPANSION (dream big), HOLD SCOPE (maximum rigor), SCOPE REDUCTION (strip to essentials). Use when the user asks for a plan review, CEO review, mega review, or wants a plan challenged/stress-tested before implementation.

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