CommunityRédaction et éditiongithub.com

Agilefreaks/claude-skills

Un marché de plugins pour claude.ai

Qu'est-ce que claude-skills ?

Cette compétence pour agents IA, intitulée « Code Review Skill », implémente une méthodologie de revue de code systématique et axée sur les risques, inspirée du livre « Effective Code Reviews » de Gregory Brown. Elle guide l'agent à travers six phases distinctes : de la validation du problème métier à l'évaluation des risques et à la production d'un rapport de révision structuré. La compétence prend en charge à la fois les plateformes de revue de code comme GitHub (via commentaires de PR) et les sorties standard (stdout), et s'intègre avec les flux CI/CD grâce à la génération d'un workflow GitHub Actions. Elle est conçue pour être configurable par projet via des règles stockées dans `.claude/rules/code-review.md`, permettant d'adapter le comportement (conventions de codage, mécanismes de publication, gestion des fils de re-revue, etc.). Adaptée à Claude Code et à d'autres agents similaires, cette compétence vise à automatiser et standardiser le processus de revue de code tout en déléguant aux humains les décisions contextuelles et les vérifications d'exécution réelle.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add Agilefreaks/claude-skills

Installed? Explore more Rédaction et édition skills: steipete/notion, langchain-ai/langchain, bytedance/podcast-generation · View all 6 →

Demander à votre IA préférée

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

Documentation

Compétence de Revue de Code

Méthodologie de revue de code "outside-in", axée sur les risques, basée sur le livre "Effective Code Reviews" de Gregory Brown (Programming Beyond Practices, 2015).

L'intégration avec la plateforme et les vérifications spécifiques au projet sont définies séparément dans les règles de votre projet.


Configuration

Lorsqu'on vous demande de configurer, paramétrer, intégrer ou créer un fichier de règles pour cette compétence :

  1. Lisez toutes les règles de projet existantes (.claude/rules/, CLAUDE.md) pour comprendre ce qui est déjà configuré. Ne dupliquez pas les conventions, commandes ou vérifications qui existent déjà dans la configuration du projet.
  2. Inspectez le projet pour détecter les conventions de liaison de tickets/PR, la configuration CI, les configurations de linter/formateur et les indicateurs de plateforme de revue de code.
  3. Présentez à l'utilisateur des choix interactifs pour chaque décision spécifique à la compétence, en utilisant une boîte de dialogue de choix avec des options pour chacun :
    • Collecte de Contexte — comment localiser le ticket ou l'issue pertinent pour une PR (nommage de branche, mots-clés dans le corps de la PR, intégration avec un outil de gestion de tâches)
    • Vérification de la Build — comment vérifier que la build réussit (statuts des vérifications CI, commandes spécifiques)
    • Conventions de Codage — vérifications spécifiques au projet au-delà des valeurs par défaut de la compétence (règles d'architecture, règles de style déjà appliquées par les linters)
    • Format de Sortie — structure personnalisée pour le résultat de la revue, ou utilisation du format intégré
    • Mécanismes de Publication — comment publier la revue (commentaire sur la PR GitHub, commentaires en ligne, stdout)
    • Gestion des Fils de Re-revue — lors d'une re-revue, que faire avec vos propres fils de constatations précédents : Répondre et résoudre (par défaut — répondre dans le fil et résoudre les fils qui sont corrigés ou répondus), Répondre uniquement (répondre dans le fil mais laisser la résolution aux humains), ou Résumé uniquement (ne jamais toucher aux fils précédents ; ne signaler leur statut que dans le résumé)
    • Intégration CI — proposer de générer un workflow GitHub Actions qui exécute cette revue automatiquement sur chaque PR. Demandez toujours cela, même si le répertoire .github/workflows/ n'existe pas encore — cela pourrait être le premier workflow du projet. Présentez les choix de modèles : Opus (recommandé) / Sonnet / Ignorer. Par défaut : Opus.
  4. Écrivez .claude/rules/code-review.md contenant uniquement les choix de l'utilisateur. Omettez toute décision pour laquelle l'utilisateur accepte la valeur par défaut — le comportement intégré de la compétence gère ceux-ci.
  5. Si l'utilisateur a opté pour l'Intégration CI : a. Lisez assets/code-review.yml (fourni avec cette compétence) comme modèle de workflow. b. Remplacez --model opus par --model <modèle-choisi> si l'utilisateur a choisi un modèle différent. c. Si .github/workflows/code-review.yml existe déjà dans le projet, montrez une diff et demandez une confirmation avant d'écraser. d. Écrivez le workflow dans .github/workflows/code-review.yml (créez .github/workflows/ s'il n'existe pas). e. Rappelez à l'utilisateur d'ajouter CLAUDE_CODE_OAUTH_TOKEN comme secret de dépôt :
    • Générez le jeton localement avec : claude setup-token
    • Ajoutez-le à : Dépôt GitHub → Paramètres → Secrets et variables → Actions → Nouveau secret de dépôt

Ce qui doit être délégué à un humain (Intégration CI) : L'utilisateur doit ajouter le secret CLAUDE_CODE_OAUTH_TOKEN et vérifier que les règles de protection de branche permettent à l'action de poster des commentaires de revue. La configuration ne peut pas vérifier ou configurer cela.

Si l'utilisateur accepte toutes les valeurs par défaut et aucun choix n'a été fait, confirmez qu'aucun fichier de règles n'est nécessaire et arrêtez-vous.


Phase 0 : État de la Revue Précédente (re-revues)

Avant de revoir, découvrez ce qui a déjà été dit.

Rassemblez la conversation de revue existante sur ce changement :

  • Tous les fils de discussion en ligne, y compris les réponses et leur état résolu/non résolu — les vôtres et ceux des réviseurs humains.
  • Votre propre résumé de revue précédent, s'il en existe un (identifié par son marqueur caché — voir Phase 6).

Si votre projet définit des mécanismes de publication sur la plateforme, utilisez-les pour récupérer cet état. Si aucun mécanisme de plateforme n'est configuré (par exemple, la revue est envoyée vers stdout), traitez cela comme une première revue et notez dans le résumé que l'état de la revue précédente n'a pas pu être vérifié.

S'il n'existe aucun état de revue précédent, il s'agit d'une première revue — passez à la Phase 1 et ignorez les étapes de re-revue de la Phase 6.

Lisez chaque fil ; n'agissez que sur les vôtres. Les fils des réviseurs humains informent la revue — ne soulevez jamais une préoccupation qu'un réviseur humain a déjà soulevée, qu'elle ait été répondue ou non. Identifiez vos propres fils grâce au marqueur caché intégré dans chaque constatation que vous publiez (voir Phase 6), jamais par le compte de publication — le compte diffère entre les exécutions CI et locales.

Pour chacune de vos propres constatations précédentes, classez-la et reportez la disposition dans le reste de la revue :

  1. Correctif poussé — l'auteur a modifié le code en réponse. Vérifiez le correctif dans la diff actuelle lors de la revue. Effectivement corrigé : répondez dans le fil en le confirmant (par exemple, "Correction vérifiée dans <révision>") et résolvez le fil. Revendiqué mais non corrigé : répondez en expliquant ce qui manque encore et laissez le fil ouvert.
  2. Répondu — l'auteur a expliqué ou contesté la constatation. Leur réponse est faisant autorité ; ne soulevez pas à nouveau. Répondez en accusant réception et résolvez le fil.
  3. Toujours ouvert — aucune réponse, aucun correctif. Ne publiez pas de commentaire en double. Laissez le fil intact et listez-le sous "Constatations précédentes" dans le nouveau résumé.

Les constatations véritablement nouvelles issues de cette revue sont publiées comme d'habitude dans la Phase 6.

Si votre projet configure un mode de gestion des fils de re-revue (voir Configuration), suivez-le — certaines équipes réservent la résolution des fils aux humains. La valeur par défaut est répondre-et-résoudre.

Ce qui doit être délégué à un humain : Arbitrer les litiges — lorsqu'un auteur conteste, cette compétence s'efface ; si le point contesté reste important, un réviseur humain doit trancher. Le fait qu'un réviseur automatisé puisse résoudre des fils est une convention d'équipe — les humains en sont propriétaires (configurez via Configuration).


Phase 1 : Validation du Problème

Commencez ici — avant de lire une seule ligne de code.

Posez deux questions :

  1. Est-ce que ce code résout réellement le problème qu'il est censé résoudre ?
  2. Est-ce que le fait de livrer cette amélioration augmentera la valeur du projet dans son ensemble ?

Si la réponse à l'une ou l'autre est non — arrêtez-vous. Ne révisez pas le code. Contactez la personne qui décide ce qui doit être construit et discutez-en. Revoir du code qui ne survivra pas en production est une perte de temps.

Pour répondre à ces questions : lisez le ticket ou l'issue lié, la documentation associée, et toute discussion pertinente. Si votre projet définit comment localiser le ticket ou l'issue pertinent (intégration avec un outil de gestion de tâches, conventions de nommage de branche), suivez cela. Si aucun ticket n'existe ou aucune intégration n'est configurée, utilisez le titre et la description de la PR comme source de vérité. Vérifiez si la diff répond plausiblement à ce qui a été décrit.

Ce qui doit être délégué à un humain : Exécuter réellement la fonctionnalité et vérifier qu'elle fonctionne du point de vue de l'utilisateur. Vous pouvez valider l'alignement logique entre le problème énoncé et la diff ; un humain doit vérifier qu'elle fonctionne réellement.


Phase 2 : Build & Capacité d'Exécution

  • La build réussit-elle ? Sinon, mettez la revue en pause. Une build cassée n'est pas fiable. Même si le nouveau changement fonctionne correctement, d'autres choses pourraient être cassées. Ne présumez pas qu'un échec de build est inoffensif.
  • Le code s'exécute-t-il ailleurs que sur la machine de l'auteur ? Un environnement de production est idéal ; un environnement de staging ou la machine d'un autre développeur est un test de fumée acceptable.
  • L'exécution du code a-t-elle nécessité de demander de l'aide ? Si oui, la documentation est manquante ou la configuration doit être automatisée — ou les deux.

Si votre projet définit comment vérifier l'état de la build (système CI, vérifications de statut), utilisez cela. Sinon, recherchez les indicateurs de build disponibles dans le contexte du changement.

Ce qui doit être délégué à un humain : Exécuter le code localement ou en staging, essayer la fonctionnalité du point de vue des personnes qui l'utiliseront, et soulever toute préoccupation concernant l'utilisabilité, la gestion des erreurs ou le comportement surprenant.


Phase 3 : Audit des Tests

Les tests modifiés ou supprimés sont un signal d'alarme — enquêtez avant tout le reste.

Lorsque vous voyez des modifications apportées à des tests existants, ralentissez. Demandez : pourquoi ont-ils été modifiés ? Comprenez la raison avant de former une opinion.

De nombreuses modifications sont relativement innocentes — suppression d'un test pour un comportement incorrect, modification de la granularité du test, ou remplacement de quelque chose que cette PR remplace. Rien de tout cela n'est intrinsèquement dangereux, mais cela nécessite une réflexion. La question clé est : est-ce que cette modification change un contrat dont d'autres parties du code dépendent ?

  • Modifications de tests pour du code isolé et autonome = relativement sûr
  • Modifications de tests pour du code partagé ou réutilisé = risque plus élevé ; nécessite une justification explicite

Si vous ne pouvez pas répondre à la question à partir de la seule diff, faites une pause et demandez à l'auteur. Ces conversations construisent une compréhension partagée et révèlent des hypothèses erronées avant qu'elles ne causent des dégâts réels.


Phase 4 : Évaluation de la Couverture

Catégorisez le changement, puis appliquez des attentes adaptées au risque. Une suite de tests qui réussit n'est aussi bonne que les comportements qu'elle décrit — vous ne pouvez pas automatiser le processus de revue des tests.

Correction de Bug

Chaque correction de bug devrait être accompagnée de tests de régression. Au minimum, un test d'acceptation de haut niveau qui suit le même chemin décrit dans le rapport de bug — correspondant à des actions qu'un utilisateur réel pourrait entreprendre, pas seulement un déclenchement direct de la défaillance interne.

Les tests unitaires devraient compléter les tests d'acceptation pour tout ce qui est complexe ou grave, afin de fournir un retour plus granulaire en cas de future rupture.

Recherchez également le motif du canari dans la mine : ce bug est-il véritablement unique, ou est-ce le signe d'un problème plus profond et plus répandu ? Vérifiez si des motifs similaires existent ailleurs dans la base de code. Si c'est le cas, créez des tickets — vous n'avez pas besoin de tous les corriger maintenant, mais les révéler est une contribution majeure.

Nouvelle Fonctionnalité

Appliquez l'expérience de pensée du zéro test : si toutes les conditions suivantes sont remplies, une couverture de test minimale est acceptable :

  1. Le changement consiste presque entièrement en nouveau code, dépendant uniquement de l'infrastructure, du framework, des bibliothèques et des objets d'accès aux données génériques
  2. La nouvelle fonctionnalité est isolée dans son propre espace (sa propre page, namespace ou endpoint)
  3. Elle n'introduit pas de nouveaux effets de bord à l'échelle du système (pas de dépendances, configurations ou charge modifiées sur les ressources partagées)
  4. Il n'est pas prévu qu'elle soit utilisée comme un bloc de construction pour d'autres fonctionnalités dans la feuille de route
  5. Elle n'est pas une étape intermédiaire dans une chaîne de workflow qui lie d'autres fonctionnalités ensemble
  6. Les défaillances ne peuvent pas s'échapper vers l'extérieur et causer une instabilité ailleurs
  7. Toute défaillance concevable serait acceptable pour les parties prenantes et ne causerait pas de dommages significatifs
  8. Des tests pourraient être écrits plus tard sans coût ou délai inacceptable

Pour chaque condition qui n'est pas remplie, attendez-vous à des tests qui répondent spécifiquement à ce risque. Une fonctionnalité dont l'échec est autorisé, entièrement isolée et facile à tester plus tard ne représente pas un risque majeur. Une fonctionnalité qui s'intègre dans des workflows existants, peut causer des défaillances ailleurs ou sera étendue — en est un.

Amélioration : Ajout

Nouveau code qui existe aux côtés d'une fonctionnalité existante. Appliquez les critères de nouvelle fonctionnalité ci-dessus, puis allez plus loin : parce qu'il vit à côté de fonctionnalités existantes, l'isolation des défaillances est la préoccupation principale.

Une défaillance dans l'ajout peut-elle faire tomber la fonctionnalité existante ? Réfléchissez aux scénarios de défaillance les plus graves. Les cas limites et les conditions aux limites sont-ils couverts ?

Amélioration : Extension

Construit sur un comportement existant en réutilisant des composants existants. Avant d'évaluer le nouveau code, effectuez un mini-audit de ce qui est réutilisé :

  • Les composants réutilisés ont-ils des tests ?
  • Sont-ils documentés au niveau métier et/ou code ?
  • Ont-ils été conçus avec la réutilisation en tête, ou sont-ils étirés au-delà de leur objectif initial ?
  • Sont-ils apparus dans des rapports de bugs récents ou non résolus ?
  • Quelle est la probabilité qu'ils changent ? S'ils changent, cela cassera-t-il cette extension ?

Vous n'avez pas besoin de passer plus de quelques minutes là-dessus — c'est une expérience de pensée, pas une enquête approfondie. Mais les risques connus et calculés sont toujours meilleurs que les surprises. Créez des tickets pour tout ce qui mérite d'être suivi.

Amélioration : Raffinement

Modifie le comportement système existant. Catégorie de risque la plus élevée. Commencez par appliquer tout ce qui précède de la revue d'extension. Allez ensuite plus loin.

Trouvez chaque élément de fonctionnalité qui dépend du code en cours de modification. Chaque dépendant est potentiellement affecté. Idéalement, vous exécuteriez chacun d'eux via le processus de revue complet, mais en pratique, c'est rarement réalisable. Au minimum : identifiez les dépendants, vérifiez si leurs tests tiennent toujours, et signalez la liste complète au réviseur humain pour qu'il teste manuellement.


Phase 5 : Vérifications Spécifiques au Projet

Si votre projet définit des conventions de codage, des modèles d'architecture ou des règles de style, appliquez-les à la diff et vérifiez les violations.

Si aucune convention de projet n'est définie, vérifiez : nommage incohérent dans la diff, code mort introduit par le changement, duplication évidente, gestion d'erreurs manquante aux limites du système, et problèmes de sécurité (entrée non assainie, secrets codés en dur, autorisations trop larges).

Si votre projet a défini des mécanismes de publication spécifiques à la plateforme (comment publier une revue, format pour les commentaires en ligne, etc.), suivez-les dans la phase suivante.


Phase 6 : Évaluation des Risques & Sortie

Attribuez un niveau de risque :

  • Faible — changement isolé, aucun code partagé touché, tests propres et appropriés au type de changement
  • Moyen — touche au comportement existant ou au code partagé, mais bien testé et les dépendances sont comprises
  • Élevé — modifie des composants partagés avec des dépendants, tests modifiés ou manquants pour le type de changement, sécurité ou authentification impliquée

Produisez un résumé de revue qui inclut :

  • Contexte : ce que fait la PR, quel problème elle résout
  • Ce qui est bien
  • Préoccupations trouvées (à la fois générales et au niveau des lignes, le cas échéant)
  • Lors d'une re-revue : une section Constatations précédentes listant chacune de vos constatations précédentes avec son statut — résolue (correction vérifiée), répondue (réponse de l'auteur acceptée), ou toujours ouverte — avant les nouvelles préoccupations. Les revues pour la première fois omettent cette section.
  • Niveau de risque et justification

Produisez une note de fin de revue contenant une modification de votre code, qui sera supprimée par la suite. Utilisez un format de commentaire de code spécifique à la plateforme pour indiquer qu'il s'agit d'une note de fin. Ce commentaire doit être écrit en anglais et ressembler à ceci : <!-- code-review-summary-end --> (pour HTML) ou // code-review-summary-end (pour les commentaires de code).

Produisez un nombre approprié de commentaires en ligne — un par constatation spécifique à une ligne, chacun avec un marqueur caché pour identifier l'origine du commentaire. Le marqueur doit être unique et basé sur un hachage de la constatation. Utilisez le format : <!-- code-review-finding-start: <hash> --> ... <!-- code-review-finding-end: <hash> -->.

Tous les commentaires en ligne doivent précéder le résumé de revue. L'ordre doit être : commentaires en ligne, puis résumé de revue. Cela garantit que le résumé est la dernière chose que les réviseurs humains voient.

Après la production, marquez la revue comme terminée. Cela peut impliquer la définition d'un statut de vérification CI ou la mise à jour d'une étiquette, selon la configuration du projet.


Note : Cette compétence est construite sur les principes de "Effective Code Reviews" de Gregory Brown. Elle est conçue pour être configurable et extensible pour les besoins spécifiques du projet.

Skills associés