Communitygithub.com

cdcoonce/Portfolio_Website

Interroge systématiquement l'utilisateur au sujet d'un plan ou d'une conception jusqu'à parvenir à une compréhension partagée, en résolvant chaque embranchement de l'arbre de décision. À utiliser lorsque l'utilisateur souhaite tester un plan, être challengé sur sa conception ou mentionne « grille-moi ».

Qu'est-ce que Portfolio_Website ?

Cette compétence transforme l'agent en un interlocuteur rigoureux qui passe au crible chaque aspect d'un plan ou d'une conception, branche par branche, jusqu'à ce qu'une compréhension partagée soit atteinte. Elle est idéale pour les développeurs travaillant avec des agents comme Claude Code, Cursor ou Codex, qui souhaitent éviter les hypothèses implicites avant de commencer l'implémentation. Le processus commence par une phase de lecture silencieuse du plan et du code existant, suivie d'une série de questions structurées par domaines d'interrogation (intention, architecture, données, etc.). L'agent utilise systématiquement l'outil `AskUserQuestion` pour poser des questions, regroupe les questions connexes par lots de 4 maximum, et recommande toujours une option en premier. Un journal des décisions est tenu sous forme de tableau structuré dans la conversation. La compétence garantit qu'aucune hypothèse ne subsiste et que l'utilisateur confirme explicitement chaque décision, ce qui réduit les retours en arrière coûteux et améliore la qualité des livrables.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Grill Me — Compréhension partagée par interrogation systématique

Philosophie

Le but du grillage est de construire une compréhension partagée entre l'agent et l'utilisateur. Chaque plan contient des hypothèses implicites, des contraintes non énoncées et des décisions ambiguës. Le grillage parcourt chaque branche de l'arbre de décision, une par une, jusqu'à ce que les deux parties soient parfaitement alignées.

L'objectif est zéro hypothèse non examinée avant le début de l'implémentation.

Directives principales

  1. Utilisez AskUserQuestion pour chaque question. Toutes les questions d'interrogation doivent passer par l'outil AskUserQuestion. Ne produisez jamais une question sous forme de texte brut.
  2. Regroupez par domaine. Regroupez jusqu'à 4 questions connexes dans le même domaine d'interrogation en un seul appel AskUserQuestion. Ne mélangez jamais des questions de domaines différents dans un même appel.
  3. Commencez par votre recommandation. Votre réponse recommandée est toujours la première option, avec (Recommandé) ajouté au libellé.
  4. Explorez avant de demander. Si une question peut être répondue en lisant la base de code, en lisant la documentation ou en vérifiant les motifs existants — faites-le plutôt que de demander. Ne posez à l'utilisateur que des questions qui nécessitent son jugement.
  5. Résolvez les dépendances dans l'ordre. Certaines décisions dépendent d'autres. Identifiez la chaîne de dépendances et résolvez d'abord les décisions en amont.
  6. Suivez tout avec des enregistrements structurés. Tenez un journal des décisions sous forme de tableau structuré. Pour chaque question résolue, enregistrez : domaine, sujet (en-tête), libellé de l'option choisie, et tout texte personnalisé si 'Autre' a été choisi. Présentez le journal dans le contexte de la conversation — pas d'E/S de fichier.
  7. Aucune hypothèse ne survit. Si quelque chose est implicite mais non dit, mettez-le en surface. Si quelque chose semble évident, confirmez-le. Une compréhension partagée signifie un accord explicite, pas un silence confortable.
  8. Restez concret. Formulez les questions autour de comportements spécifiques, de flux de données et de résultats visibles par l'utilisateur — pas de concepts abstraits.

Configuration pré-interrogation

Avant de poser des questions, construisez le contexte en silence :

  1. Lisez le plan ou le document de conception que l'utilisateur souhaite voir griller
  2. Explorez la base de code pour les motifs existants, les contraintes et le code pertinent
  3. Vérifiez l'historique git récent pour le contexte du travail en cours
  4. Lisez project.md et CLAUDE.md pour les conventions du projet

Présentez ensuite un bref résumé de ce que vous comprenez jusqu'à présent, organisé par domaines d'interrogation. Cela donne à l'utilisateur la possibilité de corriger les malentendus majeurs avant de plonger dans le questionnement branche par branche.

Domaines d'interrogation

Travaillez à travers les domaines définis dans references/interrogation-domains.md. Adaptez l'ordre au plan — commencez par le domaine le plus central à ce qui est construit et élargissez-vous. Sautez les domaines clairement non pertinents.

Processus d'interrogation

1. Lisez et résumez votre compréhension du plan
2. L'utilisateur confirme ou corrige le résumé
3. Pour chaque domaine d'interrogation (classé par pertinence) :
   a. Identifiez tous les points de décision et hypothèses dans ce domaine
   b. Regroupez les points de décision connexes en lots de 4 questions maximum
   c. Pour chaque lot, invoquez un seul appel AskUserQuestion
      (recommandation en premier pour chaque question). Enregistrez toutes les options choisies.
   d. Après avoir résolu tous les points d'un domaine, résumez les décisions prises
      Présentez les décisions du domaine sous forme de lignes dans le format de tableau structuré.
4. Après avoir couvert tous les domaines :
   - Présentez le journal complet des décisions sous forme de tableau structuré :
     | # | Domaine | Sujet | Décision | Notes |
     |---|---------|-------|----------|-------|
     | 1 | Intention | Objectif | Autre | Tableau de bord interne pour l'équipe Ops, pas orienté client |
   - Signalez tout élément non résolu ou différé
   - Demandez si un domaine doit être revisité

Format des questions

Chaque question DOIT être posée via l'outil AskUserQuestion. Structurez chaque appel comme suit :

{
  "question": "Quand l'API Oura renvoie une 429, comment devons-nous gérer la limitation de débit ?",
  "header": "Limites",
  "options": [
    {
      "label": "Backoff exponentiel (Recommandé)",
      "description": "Réessayer avec backoff exponentiel (1s, 2s, 4s). Gère les limites transitoires avec élégance et correspond au motif de réessai déjà utilisé dans src/api_client.py."
    },
    {
      "label": "Mettre en file d'attente pour la prochaine exécution",
      "description": "Ignorer la demande et l'ajouter à la prochaine exécution planifiée. Plus simple mais retarde les données d'un cycle."
    }
  ],
  "multiSelect": false
}

Dépend de : Indiquez toutes les décisions antérieures sur lesquelles cela s'appuie dans le texte de la question, ou mentionnez « Aucune dépendance » si indépendant.

Exemple de questions regroupées

{
  "questions": [
    {
      "question": "Quelle est la cible de déploiement principale ?",
      "header": "Déploiement",
      "options": [
        {
          "label": "Docker + ECS (Recommandé)",
          "description": "Correspond à l'infrastructure existante. Le pipeline de déploiement existe déjà."
        },
        {
          "label": "Kubernetes",
          "description": "Plus flexible mais nécessite une nouvelle configuration d'infrastructure."
        },
        {
          "label": "Serverless",
          "description": "Charge opérationnelle plus faible mais latence de démarrage à froid préoccupante."
        }
      ],
      "multiSelect": false
    },
    {
      "question": "Quelles approches de surveillance devrions-nous inclure ?",
      "header": "Monitoring",
      "options": [
        {
          "label": "Journalisation structurée (Recommandé)",
          "description": "Journaux JSON vers CloudWatch. Interrogeables et alertables."
        },
        {
          "label": "Traces APM",
          "description": "Traçage distribué pour la visibilité du flux de requêtes."
        },
        {
          "label": "Métriques personnalisées",
          "description": "Compteurs et jauges spécifiques à l'activité dans Datadog."
        }
      ],
      "multiSelect": true
    }
  ]
}

Utilisation des aperçus

Utilisez le champ preview sur les options lorsque l'utilisateur a besoin de comparer visuellement des artefacts concrets — extraits de code, diagrammes d'architecture, formes de schémas ou exemples de configuration. Le contenu de l'aperçu s'affiche en markdown dans un bloc monospace avec comparaison côte à côte.

Quand utiliser les aperçus :

  • Comparer deux motifs de code ou implémentations
  • Montrer différentes formes de schémas ou structures de données
  • Présenter des alternatives d'architecture avec des diagrammes ASCII

Contrainte : Les aperçus sont à sélection unique uniquement (multiSelect: false). Si vous avez besoin de sélection multiple, omettez les aperçus et utilisez des descriptions à la place.

Exemple avec aperçus :

{
  "question": "Quel motif devrions-nous utiliser pour le pipeline de données ?",
  "header": "Pipeline",
  "options": [
    {
      "label": "Pipeline générateur (Recommandé)",
      "description": "Évaluation paresseuse, économe en mémoire pour les grands ensembles de données.",
      "preview": "def pipeline(source):\n    for record in source:\n        cleaned = clean(record)\n        validated = validate(cleaned)\n        yield validated"
    },
    {
      "label": "Pipeline par lots",
      "description": "Traite tous les enregistrements en une fois. Plus simple mais utilisation mémoire plus élevée.",
      "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
}

Règles pour poser des questions

  • Utilisez AskUserQuestion pour chaque question. Point final.
  • Première option = recommandation. La première option a toujours (Recommandé) dans le libellé.
  • Regroupez les questions connexes. Regroupez jusqu'à 4 questions connexes du même domaine en un seul appel AskUserQuestion. Les questions de différents domaines doivent être des appels séparés.
  • Respectez les contraintes de l'outil. 2 à 4 options par question. En-têtes de 12 caractères maximum. Utilisez multiSelect: true lorsque les options ne s'excluent pas mutuellement (par exemple, « Quelles approches de test devrions-nous utiliser ? » ou « Quels domaines nécessitent une couverture ? »).
  • Filtrez les options. Lorsqu'il existe plus de 4 choix valides, présentez les 3 plus pertinents en fonction du contexte de la base de code. Les utilisateurs sélectionnent « Autre » pour tout ce qui n'est pas listé.
  • Soyez spécifique. « Comment devrions-nous gérer les erreurs ? » est trop vague. « Quand l'API Oura renvoie une 429, devrions-nous réessayer avec backoff ou mettre en file d'attente pour la prochaine exécution ? » est spécifique.
  • Montrez votre travail. Si votre recommandation est basée sur quelque chose que vous avez trouvé dans la base de code, référencez le fichier et la ligne.
  • Acceptez la réponse. Lorsque l'utilisateur décide, enregistrez-la et passez à autre chose. Ne revenez pas sur la décision à moins qu'une décision ultérieure ne crée un conflit avec une précédente.

Solution de repli (AskUserQuestion indisponible)

Si AskUserQuestion n'est pas disponible dans l'environnement d'exécution, utilisez ce format texte :

[En-tête] — [Sujet]

[Énoncé clair de la question]

Recommandé : [Votre recommandation et pourquoi]

Alternatives :

  • (A) [Option] — [compromis]
  • (B) [Option] — [compromis]

Quand s'arrêter

Le grillage est terminé lorsque :

  • Chaque domaine d'interrogation pertinent a été couvert
  • Toutes les branches de décision ont été résolues ou explicitement différées
  • L'utilisateur confirme la compréhension partagée

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.

Skills associés