steipete/github-deep-review

Révision approfondie GitHub : bugs, PRs, meilleure correction, obsolète ou réel, lire le code d'abord.

Qu'est-ce que github-deep-review ?

Cette compétence pour agents IA effectue une révision de code GitHub de haut niveau, en suivant une méthodologie rigoureuse centrée sur les preuves. Contrairement aux résumés génériques, elle exige de l'agent qu'il comprenne la classe du bogue, identifie la cause racine en lisant le code en profondeur, et détermine la meilleure correction possible, tout en évaluant si une refactorisation plus large améliorerait la conception. Elle utilise des commandes `gh` pour récupérer les détails des issues et des PRs, inspecte le code local avec `git` et `rg`, et suit un contrat de révision explicite pour répondre à des questions clés comme l'URL, la cause racine, la provenance, la qualité du correctif, et les risques résiduels. La sortie est structurée selon un modèle concis incluant ref, surface, bug, cause, provenance, meilleur correctif, refactorisation, preuve et risque. Cette compétence est conçue pour des plateformes comme Claude Code, Cursor, ou Codex, et met l'accent sur une lecture de code au-delà du premier fichier touché, en suivant le chemin d'appel réel et en vérifiant les dépendances auprès de leurs sources en amont. Elle inclut également la génération de notes de contributeur après une interaction qui crée un signal durable pour les révisions futures, en s'appuyant sur un workflow d'auteur contextuel.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/steipete/agent-scripts/tree/main/skills/github-deep-review

Installed? Explore more Recherche et analyse de données skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · 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

GitHub Deep Review

Révisez comme Peter : haute confiance, fondé sur les preuves, conscient du code, et prêt à dire « non prouvé » quand la piste est faible. L'objectif n'est pas un résumé générique. L'objectif est de comprendre la classe du bogue, de trouver la cause réelle si possible, de décider de la meilleure correction après avoir lu suffisamment de code, et de signaler si une refactorisation plus large améliorerait la conception.

Début

Utilisez gh, pas la navigation web, pour les références GitHub :

gh issue view <n> --json number,title,state,author,body,comments,labels,updatedAt,url
gh pr view <n> --json number,title,state,author,body,comments,reviews,files,commits,statusCheckRollup,mergeStateStatus,headRefName,headRepositoryOwner,url
gh pr diff <n> --patch

Pour les PRs, collectez le contexte de l'auteur par défaut, sauf si l'auteur est Peter (steipete ou un compte appartenant clairement à Peter). Utilisez le workflow local dans ~/Projects/agent-scripts/skills/github-author-context/SKILL.md et incluez un court bloc Contexte de l'auteur: près du début de la révision lorsque l'auteur n'est pas Peter. Après fusion/rejet/fermeture/révision, utilisez le même workflow de contexte d'auteur pour ajouter une note de contributeur uniquement lorsque l'interaction crée un signal durable pour les révisions futures.

Pour la révision locale du dépôt, inspectez également :

git status --short --branch
git fetch origin
git log --oneline --decorate -20
rg "<symbole/erreur/config/endpoint clé>"

Si le dépôt contient des instructions locales, des compétences pour issues/PRs, des listes de documentation, des conseils de test ou des manuels de maintenance, lisez-les avant de décider.

Contrat de Révision

Répondez toujours à ces questions, explicitement :

  • URL/ref : numéro d'issue ou de PR et surface affectée.
  • Quel est le bogue ou le comportement corrigé ?
  • Pouvons-nous identifier la cause racine ? Si oui, où dans le code et pourquoi. Si non, quelle preuve manque-t-il.
  • Pour les régressions, qui/quoi l'a introduite et quand ? Incluez la provenance du commit/PR lorsqu'elle est traçable par historique borné ; dites « inconnu » au lieu de deviner.
  • La correction actuelle/proposée est-elle la meilleure correction possible après avoir lu le code adjacent ?
  • Une refactorisation plus large améliorerait-elle l'exactitude, la clarté ou la maintenabilité future ?
  • Quelle preuve existe : tests, reproduction en direct, vérifications CI, documentation, documentation/source des dépendances, comportement livré/actuel.
  • Qu'est-ce qui reste risqué ou non vérifié.

Profondeur de Lecture du Code

Lisez au-delà du premier fichier touché. Suivez le chemin d'appel réel :

  • point d'entrée -> validation/analyse -> routage/distribution -> module propriétaire -> helper partagé -> limite de persistance/réseau/exécution
  • configuration/schéma/documentation -> utilisation à l'exécution -> chemin de correction/docteur/migration
  • fournisseur/canal/plugin code propriétaire -> jointure générique du noyau, seulement si plusieurs propriétaires en ont besoin
  • tests autour de la surface touchée plus les tests de régression adjacents

Lorsque le comportement dépend d'une dépendance, lisez la documentation/le type/le contrat actuel du paquet en amont avant de présumer.

Préférez la source actuelle et la preuve exécutable aux commentaires d'issues. Traitez les commentaires obsolètes, les anciennes CI et les comportements d'anciennes versions comme des indices jusqu'à vérification.

Provenance

Pour les révisions de bogues/régressions, incluez une réponse compacte Provenance : lorsque c'est faisable :

  • Utilisez git log -S/-G, git blame, les PRs/issues liés et les tests.
  • Séparez l'auteur, le committeur/mergeur et l'auteur actuel de la PR lorsqu'ils diffèrent.
  • Formulez comme « introduit par », « rendu visible par » ou « perpétué par ».
  • Incluez la confiance : clair, probable ou inconnu.
  • Pour les fonctionnalités, la documentation, les refactorisations ou les bogues introuvables, écrivez N/A ou dites quelle preuve manque.

Barre de Qualité des Corrections

Les bonnes corrections généralement :

  • se situent à la limite de propriété où le bogue appartient
  • préservent le comportement public/rétrocompatible sauf si le problème concerne son abandon
  • ajoutent un test de régression à la jointure la plus petite et la plus significative
  • évitent les cas spéciaux larges, les migrations cachées, les sentinelles sémantiques et les IDs de fournisseur/canal dans le noyau générique
  • mettent à jour la documentation/changelog lorsque le comportement visible par l'utilisateur change
  • échouent clairement dans les chemins d'exécution et réparent via les chemins de docteur/migration lorsque c'est le contrat établi

Signalez quand une correction n'est qu'au niveau des symptômes. Si une refactorisation légèrement plus large rend l'invariant évident et réduit les bogues futurs, recommandez-la. Si la refactorisation élargit le risque sans améliorer la classe du bogue, dites-le.

Format de Révision de PR

Commencez par les conclusions lors de la révision d'une PR. Les conclusions nécessitent des références fichier/ligne/symbole et un mode de défaillance concret. Évitez les commentaires vagues de type « considérez ».

S'il n'y a pas de problèmes bloquants :

  • dites qu'aucun problème de correction bloquant n'a été trouvé
  • listez la preuve la plus solide vérifiée
  • nommez les risques résiduels/les lacunes de test
  • répondez si la conception est la meilleure forme disponible

N'approuvez pas, ne commentez pas, ne fermez pas, ne fusionnez pas, ne poussez pas et ne livrez pas sauf si l'utilisateur a demandé cette action.

Format de Révision d'Issue

Pour les bogues/issues :

  1. Reconstruisez le scénario du rapporteur et la version/surface affectée.
  2. Vérifiez si la branche main actuelle le corrige déjà.
  3. Reproduisez ou créez une preuve locale/en direct minimale lorsque c'est faisable.
  4. Si c'est clair, identifiez la cause racine et la correction proposée.
  5. Si résolu sur main, ne commentez/fermez que lorsque l'utilisateur le demande ; incluez la preuve et le commit/PR canonique si connu.

Si la reproduction n'est pas faisable, dites exactement ce qui la bloque et quelle preuve rendrait la décision fiable.

Modèle de Sortie

Utilisez ce format lorsque l'utilisateur demande « de quoi s'agit-il », « est-ce la meilleure correction » ou « qu'avons-nous corrigé » :

Ref : #123 / PR #456
Surface : <exécution/CLI/fournisseur/canal/documentation>

Bogue : <une ou deux phrases>
Cause : <chemin du code + confiance>
Provenance : <introduit/rendu visible/perpétué par commit/PR/date, ou N/A/inconnu>
Meilleure correction : <ce qui devrait changer et pourquoi>
Refactorisation : <oui/non, forme spécifique>
Preuve : <tests/en direct/CI/source/documentation des dépendances>
Risque : <incertitude restante>

Soyez concis, mais ne sautez pas la décision cause/correction/refactorisation/preuve.

Individual skills in this repo

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

steipete/agent-transcript

GitHub PR/issue agent transcripts: redact, preview, and insert safely.

steipete/beeper

Beeper cache: contact hints, room lookup, WhatsApp/iMessage traces, FTS.

steipete/browser-use

Existing Chrome automation: Chrome plugin first, mcporter fallback.

steipete/clawsweeper-status

ClawSweeper status: URLs, workflow health, active workers, ops snapshot.

steipete/clickclack

ClickClack ops: chat app, Hetzner deploy, DNS/docs/app, Docker rollout.

steipete/cloudflare-registrar

Cloudflare Registrar: domain availability, prices, registration via mcporter.

steipete/codex-debugging

Codex debugging: codex-rs core/tui/exec/cli/app-server/config.

steipete/create-cli

CLI UX/spec: args, flags, help, output, errors, config, dry-run.

steipete/discord-clawd

Discord-backed OpenClaw agent/session relay; not archive search.

steipete/domain-dns-ops

DNS/domain ops: registrars, zones, redirects, DNS/HTTP verify, manager truth.

steipete/frontend-design

Frontend UI: pages, apps, components, polished non-generic design.

steipete/github-author-context

GitHub contributor context: identity, activity, trust, company/team signal.

steipete/github-cache-hygiene

GitHub quota/cache hygiene: gh, ghx, xcache, gitcrawl, mirrors, limits.

steipete/github-project-triage

GitHub issue/PR triage: queues, CI, blockers, risk, proof, next actions.

steipete/hopper-debugger

Hopper debugging: macOS/iOS binaries, ObjC/Swift symbols, dyld, LLDB.

steipete/instruments-profiling

Instruments/xctrace profiling: macOS/iOS traces, binaries, args, exports.

steipete/mac-maintenance

Mac upkeep: brew update/upgrade, pull clean repos, empty Trash.

steipete/maintainer-orchestrator

Open-source maintainer orchestration: Codex app workers, work recovery, dependencies, vision, releases.

steipete/markdown-converter

Markdown conversion: PDF, Office, HTML, data, OCR, audio, ZIP, YouTube.

steipete/nano-banana-pro

Nano Banana/Gemini image gen/edit: text/image input, 512-4K workflows.

Skills associés