ask-codex

Appelle l'agent de codage Codex d'OpenAI en mode non interactif (`codex exec`) pour solliciter des avis sur la conception, des investigations approfondies et des revues de code.

Qu'est-ce que ask-codex ?

Ce skill permet d'invoquer l'agent de codage Codex d'OpenAI via la commande `codex exec` en mode non interactif (read-only). Il est particulièrement adapté pour obtenir un second avis sur des décisions de conception ou d'implémentation, mener des investigations approfondies sur des bugs ou des problèmes de performance, et effectuer des revues de code ciblées. Comme Codex démarre à froid à chaque appel et ne connaît pas la conversation ni les résultats précédents, il est essentiel de décrire clairement le contexte, les contraintes et les fichiers concernés dans le prompt. Le skill propose deux modes d'exécution : un mode avant-plan pour des consultations rapides et un mode arrière-plan pour les tâches longues (investigations, revues). Il gère également les validations par `git diff` et les revues de code via `codex exec review`, avec des recettes précises pour éviter les pièges d'échappement shell et de perte de contexte. Les résultats sont extraits via des fichiers temporaires, et les erreurs sont visibles uniquement en cas d'échec.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add Suree33/agent-skills

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

Que fait ask-codex ?

Compétence pour appeler l'agent de codage Codex d'OpenAI avec codex exec (mode non interactif) afin de solliciter des conseils de conception et d'implémentation, des investigations approfondies et des revues de code.

Codex a tendance à enquêter de manière persistante pour améliorer la précision, ce qui le rend adapté pour un second avis ou des investigations où l'exactitude est cruciale.

Codex démarre à froid à chaque appel et ne connaît rien de la conversation, du plan ou des résultats d'investigation précédents. Les hypothèses, l'intention, les contraintes et les fichiers associés doivent être explicitement inclus dans le prompt à chaque fois (voir la section « Rédaction du message de tâche » et les exemples ci-dessous).

Prérequis

  • Le CLI codex doit être installé et authentifié (vérifiable avec codex --version).
  • Si l'authentification a expiré, une configuration du côté de Codex est nécessaire ; informez-en l'utilisateur.

Avant l'exécution

Avant d'appeler Codex, informez brièvement l'utilisateur de la consultation. Il n'est pas nécessaire d'attendre une approbation ; une fois informé, vous pouvez procéder.

Modèle d'appel de base

Codex étant un relecteur supérieur en lecture seule, utilisez -s read-only par défaut. Pour éviter les échappements shell, passez le prompt via stdin (codex exec -).

Deux pratiques essentielles :

  1. Terminez l'extraction de la réponse (cat) dans la même commande que l'appel à Codex. OUT=$(mktemp …) et la variable $OUT disparaissent dans un appel shell ultérieur, donc essayer de lire via une commande Read ultérieure entraînera une perte de chemin. En faisant cat dans la même commande, vous capturez la réponse de manière fiable sans présumer du comportement.
  2. Ne laissez pas la sortie standard/erreur de Codex entrer dans le contexte. Codex envoie les journaux de progression, en-têtes, avertissements, hooks, échos de fin et tokens used sur stderr, et seul le message final sur stdout et dans le fichier -o (tout ce qu'il fait/pense est sur stderr). Comme nous ne voulons que la conclusion, jetez stdout et redirigez stderr vers un fichier temporaire, à afficher uniquement en cas d'échec. Ainsi, le résultat de l'outil ne contient que le message final de cat "$OUT", et les causes d'erreur (authentification expirée, drapeau invalide, etc.) sont visibles en cas d'échec.

Deux recettes canoniques selon l'usage :

A. Consultation courte / petite revue (avant-plan)

La réponse (uniquement le message final) est renvoyée dans le résultat de l'outil shell. Aucune lecture supplémentaire nécessaire.

OUT=$(mktemp /tmp/codex_answer.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
printf '%s' "$PROMPT" | codex exec - -s read-only -C <DIR> -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
cat "$OUT"

B. Appel long (arrière-plan)

codex exec peut prendre plusieurs minutes, et une exécution avant-plan peut être interrompue selon l'environnement. Pour les investigations approfondies ou les revues de code avec codex exec review, déléguez à un mécanisme d'exécution en arrière-plan de votre harnais (la méthode est laissée au harnais). La commande elle-même utilise codex exec - (consultation/investigation) ou codex exec review (revue de diff, voir ci-dessous).

OUT=$(mktemp /tmp/codex_answer.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
printf '%s' "$PROMPT" | codex exec - -s read-only -C <DIR> -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
echo "=== ANSWER ==="; cat "$OUT"

Une fois terminé, le harnais envoie une notification de fin, et la sortie d'arrière-plan contient la réponse après === ANSWER ===. Lisez cette sortie (pour les longues réponses, vous pouvez grep après === ANSWER ===). Ne créez pas votre propre boucle de polling avec sleep/pgrep ; le harnais notifie la fin.

Signification des drapeaux

  • codex exec -: Lit le prompt depuis stdin. Permet de passer du texte long, des blocs de code et des caractères spéciaux en toute sécurité.
  • -s read-only: Autorise uniquement la lecture. Par défaut dans ce skill (rôle de conseiller/reviewer, pas besoin d'écriture). Ce n'est pas la valeur par défaut du CLI/config. Uniquement pour codex exec ; n'existe pas pour codex exec review (son utilisation provoque une erreur).
  • -C <DIR>: Racine de travail pour codex exec. Pointe vers le dépôt à investiguer/reviewer. Par défaut, répertoire courant. codex exec review n'a pas -C, donc pour une revue, faites cd <DIR> dans la même commande (voir ci-dessous).
  • -o <FILE>: Écrit uniquement le message final de Codex dans ce fichier. Écrit uniquement à la fin (vide pendant l'exécution), ne le lisez pas avant. La recette canonique l'utilise comme source de réponse.
  • stdout: Codex envoie aussi le message final sur stdout, mais la recette canonique le prend depuis -o, donc >/dev/null le jette (évite la duplication et économise le contexte).
  • stderr: Affiche les journaux de progression, en-têtes, avertissements, hooks, échos de fin, tokens used, et les erreurs (authentification expirée, drapeau invalide, échec de vérification du dépôt, etc.). Ne le jetez pas avec 2>/dev/null, sinon vous ne pourrez pas voir la cause si cat "$OUT" est vide. Redirigez-le vers un fichier temporaire ($ERR) et affichez-le uniquement en cas d'échec. En cas de succès, rien n'entre dans le contexte ; en cas d'échec, la cause est visible.
  • mktemp /tmp/codex_answer.XXXXXX.txt: Le suffixe XXXXXX est remplacé de manière aléatoire pour générer un chemin unique. Même en cas d'appels parallèles, chaque invocation a son propre mktemp.

Options normalement inutiles

  • --skip-git-repo-check: Nécessaire uniquement pour exécuter en dehors d'un dépôt git. Ne l'utilisez pas si vous êtes dans un dépôt.
  • -s workspace-write: Uniquement si vous voulez que Codex modifie des fichiers. Hors de la portée de ce skill (reviewer en lecture seule), donc à ne pas utiliser en principe.

Spécification du modèle

Pour utiliser un modèle spécifique, utilisez -m <MODEL> (ex: -m gpt-5.5). Si non spécifié, suit la configuration par défaut de Codex. N'utilisez pas ce drapeau sans nécessité ; ne l'ajoutez que si l'utilisateur le demande.

Recherche Web

Si web_search = "live" est défini dans ~/.codex/config.toml, Codex peut utiliser la recherche web. La recherche web est un outil natif de Responses, donc -s read-only (qui limite uniquement l'exécution shell) ne l'empêche pas. Pour vérifier des spécifications précises de librairies, APIs ou CLI, spécifiez dans le prompt : « Vérifie dans la documentation officielle avec une recherche web ». codex exec lui-même n'a pas de drapeau --search ; c'est configuré via web_search.

Affichage de l'aide

codex exec -h affiche l'aide.

Rédaction du message de tâche

Les LLM sont meilleurs avec des exemples, donc utilisez les exemples ci-dessous comme modèles directs pour le corps du prompt passé à printf. Limitez chaque consultation à une seule décision, revue, plan ou investigation, et incluez ce qui suit dans un seul prompt :

  • Intention, contexte et contraintes : Puisque Codex démarre à froid, écrivez toujours ce que vous voulez faire, pourquoi, et les hypothèses.
  • Fichiers associés : Indiquez-les en ligne avec @path/to/fichier. Si vous voulez que Codex examine les modifications actuelles, spécifiez « Vérifie les différences avec git diff ».
  • Points d'attention / alternatives à comparer / risques à identifier : Soyez précis.
  • Format de sortie : Spécifiez-le (risques classés, tableau de compromis, modification de plan recommandée, etc.).
  • Ce qu'il doit ignorer : Mentionnez ce qu'il ne doit pas prendre en compte (nommage, formatage, etc.) pour éviter la dérive de scope.
  • Si une vérification de spécifications externes est nécessaire, spécifiez « Vérifie dans la documentation officielle avec une recherche web ».
  • Pour les revues, faites-les procéder par intention → implémentation (d'abord si l'intention est correcte, puis l'implémentation).

Entourez le corps du prompt avec printf '%s' '…' en guillemets simples pour éviter que $ et les backticks ne soient interprétés par le shell (utilisez un autre type de guillemets si le texte contient des ' ASCII).

Exemples d'utilisation par type

1. Second avis / Comparaison de plusieurs propositions (recette A)

Pour obtenir un second avis sur une décision de conception ou d'implémentation. Plus vous décrivez précisément les propositions, les contraintes et le format de sortie, meilleure est la qualité.

OUT=$(mktemp /tmp/codex_answer.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
printf '%s' 'Intention : Je veux décider de la méthode de rafraîchissement des jetons d authentification. Actuellement, à chaque appel API, on vérifie la date d expiration et on rafraîchit de manière synchrone (@src/auth/client.ts), ce qui provoque des doubles rafraîchissements lors de requêtes concurrentes fréquentes.

Propositions à comparer :
(1) Partager la Promise pendant le rafraîchissement pour éviter les doublons
(2) Mettre à jour de manière proactive en arrière-plan avant l expiration
(3) Ne rafraîchir qu une seule fois après avoir reçu un 401, puis réessayer

Contraintes : Doit fonctionner en SSR et CSR. Pas de nouvelle librairie.
Sortie : Tableau de compromis (correctness / complexité / modes d échec), proposition par défaut recommandée et proposition de repli, et dans quelles conditions passer à une autre proposition. Ignore le nommage et le formatage.' \
  | codex exec - -s read-only -C /chemin/vers/depot -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
cat "$OUT"

2. Revue de code

Contrainte importante : Les drapeaux de portée de codex exec review (--uncommitted / --base / --commit) ne peuvent pas être combinés avec un PROMPT personnalisé (ni stdin - ni argument positionnel) (vérifié sur codex 0.142.4 ; leur combinaison échoue immédiatement avec error: the argument '--uncommitted' cannot be used with '[PROMPT]'). Divisez donc selon le cas :

2a. Revue avec indication de perspective/intention (usage principal recommandé de ce skill) : Comme on ne peut pas combiner drapeau de portée et indication de perspective, utilisez codex exec - (recette A/B) au lieu de codex exec review, et spécifiez la portée dans le prompt en demandant à Codex de vérifier git diff, etc. On peut utiliser -s read-only / -C / stdin directement, et éviter les échappements.

OUT=$(mktemp /tmp/codex_answer.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
printf '%s' 'Intention : Cette modification ne devrait changer le comportement que lors de la suppression du son de notification inactif, et ne devrait pas affecter la lecture du son de demande de saisie utilisateur. Vérifie les modifications non commises avec git diff (et si nécessaire git diff --cached ou les fichiers non suivis). D abord, est-ce cohérent avec l intention, ensuite regarde l implémentation.
Points d attention : Inversion de condition, changement de valeur par défaut, décalage sémantique client/serveur.
Sortie : Recommandation → constats avec preuves → hypothèses non vérifiées, dans cet ordre. Ignore le nommage et le formatage.' \
  | codex exec - -s read-only -C /chemin/vers/depot -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
echo "=== ANSWER ==="; cat "$OUT"

2b. Revue de diff brute sans indication de perspective : Si aucune instruction personnalisée n'est nécessaire, utilisez directement les drapeaux de portée de codex exec review (pas de PROMPT, donc pas de conflit avec la contrainte ci-dessus). Comme codex exec review n'a ni -C ni -s, exécutez-la depuis le dépôt cible après cd.

OUT=$(mktemp /tmp/codex_review.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
cd /chemin/vers/depot || exit 1
codex exec review --uncommitted -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
echo "=== ANSWER ==="; cat "$OUT"

Remplacement du drapeau de portée (remplacez la ligne ci-dessus ; aucun PROMPT) :

codex exec review --uncommitted -o "$OUT" >/dev/null 2>"$ERR"   # Non commis (staged + unstaged + untracked)
codex exec review --base main   -o "$OUT" >/dev/null 2>"$ERR"   # Diff par rapport à la branche de base
codex exec review --commit <SHA> -o "$OUT" >/dev/null 2>"$ERR"  # Commit spécifique
  • Pour une revue avec indication de perspective, utilisez 2a (codex exec - + git diff). Les drapeaux de portée et les instructions personnalisées ne sont pas compatibles.
  • La revue s'exécute dans le dépôt cible (pas de -C, donc faites cd d'abord). Hors du dépôt, on peut utiliser --skip-git-repo-check, mais il n'y a pas de diff à revoir.

3. Validation de plan / migration (recette B)

Stress-testez un plan ou une procédure de migration avant implémentation, et identifiez les lacunes à résoudre avant de commencer. En lecture seule, laissez Codex vérifier les contrats du code actuel.

OUT=$(mktemp /tmp/codex_answer.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
printf '%s' 'Revue le plan avant implémentation et liste seulement les lacunes à résoudre avant le codage.
Plan : Si la synchronisation d événements est rejetée par le serveur, mettre repair_required, envoyer un snapshot compact, et ne reprendre les événements incrémentaux qu après que le serveur a acquitté la séquence cohérente.
Liens : @src/sync/event-syncer.ts @src/db/sync-state.ts @api/types.ts.
Vérifie les contrats actuels en lisant le code avant d évaluer.
Points d attention : Compatibilité des schémas, limite de taille du snapshot, conditions limites de la séquence de reprise, impact du backfill/migration, tests insuffisants.
Sortie : Uniquement les modifications de plan nécessaires avant de commencer + un verdict en une phrase si on peut implémenter tel quel.' \
  | codex exec - -s read-only -C /chemin/vers/depot -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
echo "=== ANSWER ==="; cat "$OUT"

4. Investigation approfondie (recette B)

Cause racine de bugs, échecs de test, race conditions, caches obsolètes, etc. Ajouter des conditions de succès vérifiables exploite la persistance de Codex. Durée longue, donc exécution en arrière-plan.

OUT=$(mktemp /tmp/codex_answer.XXXXXX.txt)
ERR=$(mktemp /tmp/codex_err.XXXXXX.txt)
printf '%s' 'Le test TestBar dans foo_test.go échoue rarement en CI. Enquête sur la cause racine.
Conditions de succès : Identifier les conditions de reproduction et l emplacement de la cause racine (fichier:ligne), et proposer une correction minimale.
Si une librairie externe est suspectée, vérifie la documentation officielle de cette librairie avec une recherche web.' \
  | codex exec - -s read-only -C /chemin/vers/depot -o "$OUT" >/dev/null 2>"$ERR" \
  || { echo "codex failed:"; cat "$ERR"; exit 1; }
echo "=== ANSWER ==="; cat "$OUT"

Traitement des résultats

  • Transmettez les points clés à l'utilisateur à partir de la réponse (recette A : résultat d'outil, recette B : sortie d'arrière-plan après notification de fin). Si la réponse est longue, résumez tout en citant les points importants.
  • Codex peut parfois faire des propositions excessivement défensives (compatibilité arrière excessive, etc.). Jugez vous-même quelles remarques adopter et lesquelles rejeter. Ne prenez pas tout pour argent comptant ; n'incorporez que ce qui a du sens.

Skills associés