Codex : refactor et tests guidés par l’agent

À la fin, vous saurez piloter Codex pour un refactor encadré avec tests, sans réécriture dangereuse du dépôt.

Niveau : Intermédiaire · Temps estimé : 45–60 min · Dernière vérification : 2026-09-11

← CLI IDE · IA · → Codex GitHub · Workflows

Prérequis

• [ ] Codex CLI ou IDE OK
• [ ] pytest ou équivalent
• [ ] Repo lab
• [ ] Slash Codex familiarité

Coût : abonnement/tokens lab ; zéro secret. Angle DevOps Elastic Hayway.

Vous restez responsable des actions proposées.

Ce que nous allons construire

Lab refactor + tests Codex
  ├── Baseline tests rouges/verts
  ├── /plan refactor
  ├── Implémentation par petits diffs
  └── Review + commit

(Schéma — alt : « codex-refactor-tests ».)

Étape 1 — Pourquoi refactor avec agent

L’agent accélère les renommages et extractions, mais explose sans tests ni plan. Discipline : tests d’abord, plan, diffs petits, revue.

Étape 2 — Préparer la baseline

Écrivez ou générez des tests qui figent le comportement. Committez le vert. Sans filet, refusez le refactor large.

Étape 3 — Prompt de plan

Exigez un plan en étapes avec fichiers touchés, risques, et commande de test exacte. Validez avant tout edit. Slash utiles : codex-slash-commands.

Étape 4 — Stratégie de diffs

Une préoccupation à la fois (extraire fonction, puis renommer). Relancer tests après chaque étape. Abortez si l’agent réécrit hors scope.

Étape 5 — Definition of done

Tests verts, diff lisible, AGENTS.md à jour si commandes changent, NOTES.md des écarts. Pont workflows : ai-agent-workflows.

Lab concret DevOps

mkdir -p ~/lab-codex-refactor && cd ~/lab-codex-refactor
git init
cat > billing.py << 'EOF'
def price(n, premium=False):
    # legacy: magic numbers
    if premium: return n*12 + 5
    return n*10 + 3
EOF
cat > test_billing.py << 'EOF'
import billing
def test_basic():
    assert billing.price(2) == 23
def test_premium():
    assert billing.price(2, True) == 29
EOF
git add . && git commit -m "test: baseline billing"

Demandez à Codex un plan pour extraire des constantes BASE, PREMIUM_BASE, FEES sans changer les résultats tests. Appliquez par étapes, pytest -q après chaque, committez.

Erreurs fréquentes

Symptôme	Cause	Correctif
Rewrite total	Prompt vague	Borner fichiers
Tests après coup	Pas de filet	Baseline d’abord
Ignore échec pytest	Confiance	Stop + rollback
Gros bang commit	Pas d’étapes	Commits atomiques
Secret dans fixtures	Data réelle	Fictif

Quiz (4 questions)

1. Avant refactor agent :
– A. Delete tests
– B. Baseline verte + plan
– C. Always-allow

2. Bon incrément :
– A. Réécrire tout
– B. Une préoccupation + tests
– C. Skip diff

3. Si tests rouges :
– A. Forcer merge
– B. Stop, diagnostiquer, rollback si besoin
– C. Désactiver CI

4. DoD inclut :
– A. Uniquement prose
– B. Tests verts + diff lisible
– C. Secrets

Réponses : 1‑B · 2‑B · 3‑B · 4‑B

Compléments opérationnels

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.

Standard de brief réutilisable

Pour codex-refactor-tests, adoptez un brief unique partagé par l’équipe. Il contient toujours cinq champs : objectif mesurable, contexte borné (lab/staging), liste blanche de fichiers ou ressources, interdits explicites (secrets, réseau, prod), et definition of done exécutable (commande de test ou checklist). Sans ces champs, l’outil improvisera — parfois avec élégance, souvent hors périmètre.

Stockez les briefs gagnants sous briefs/codex-refactor-tests/ dans un dépôt de documentation interne. Chaque brief cite le commit de référence et le modèle utilisé. Au troisième succès comparable, ouvrez une PR qui transforme le brief en rule, Skill ou slash command. Voir ai-skills-concept, claude-skills-instructions et evaluer-qualite-skill.

Revue de diff comme compétence P0

La vitesse d’un agent n’a aucune valeur si personne ne sait lire un diff. Instituez une règle simple : aucun apply massif sans parcours hunk par hunk. Posez-vous trois questions : ce changement est-il demandé ? est-il testé ? est-il réversible ? Si une réponse est non, refusez ou exigez un plan plus petit.

En atelier, faites commenter un diff à voix haute pendant cinq minutes. Les juniors apprennent ainsi le vocabulaire du refus. Reliez cette pratique à ai-code-review-pr et aux workflows ai-agent-workflows.

Sécurité continue

Les surfaces codex-refactor-tests multiplient les occasions d’injection et de fuite. Traitez tickets, README upstream, logs et ressources MCP comme des données non fiables. Séparez instructions et données. Allowlist tools. Confirmation humaine avant mutation. Guide : ai-prompt-injection-securite, mcp-servers-devops, claude-code-mcp.

Secrets : variables d’environnement de session, gestionnaire d’équipe, rotation, jamais de commit. Si un secret fuit dans un chat vendor, supposez-le compromis et rotatez.

Coûts, modèles et mode dégradé

Documentez un mapping fast/strong et un soft-cap mensuel dans la stack perso. OpenRouter peut aider à basculer — openrouter-multi-modeles. Le local (ollama-llm-locaux + continue-dev) sert de mode dégradé ou de bac à sable confidentialité.

Surveillez les changements silencieux de modèle par défaut : une régression de qualité est souvent un routing vendor, pas « l’équipe qui a oublié comment prompter ».

Ancrage parcours

codex-refactor-tests n’est qu’une étape du parcours IA DevOps 2026. Tronc commun d’abord (prompts, injection, skills), puis surface spécialisée, puis industrialisation (routines, MCP, RAG). Hub de navigation : /ia/. Comparatifs utiles : claude-vs-gpt-code, codex-vs-claude-code, claude-vs-cursor-vs-copilot.

Rituals hebdomadaires

Hebdo : promouvoir un brief en Skill/rule ; archiver un échec instructif ; vérifier le budget tokens. Mensuel : revoir la stack (retirer l’inutile) ; rejouer un lab gold ; mettre à jour les versions d’outils. Ces rituals valent mieux que d’ajouter un cinquième abonnement.

Exemple de NOTES.md

# NOTES codex-refactor-tests
Date:
Modèle:
Brief (résumé):
Fichiers touchés:
Commande DoD:
Refus utiles:
Commit:
Leçon:

Sans ce journal, vous réapprendrez les mêmes leçons chaque sprint. Avec ce journal, vous construisez un avantage composé d’équipe.

Quand arrêter l’outil

Arrêtez la session si : le DoD échoue deux fois de suite sans diagnostic clair ; l’outil insiste pour sortir du scope ; une commande dangereuse revient après refus ; vous ne comprenez plus le diff. Dans ces cas, revenir à l’éditeur manuel + checklist est un succès de gouvernance, pas un échec personnel.

Ponts concrets vers d’autres tutoriels

Après ce lab, enchaînez selon besoin : agent CLI (claude-code-demarrer, openai-codex-intro-2026, aider-pair-programming), IDE (windsurf-cascade, continue-dev, cursor-agent-composer-2026), qualité (evaluer-qualite-skill, ai-routines-agents), ou recherche (gemini-cli-deep-research, chatgpt-search-browsing).

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.

FAQ

Quel voisin lire après codex-refactor-tests ?
Parcours · /ia/ · stack perso.

Peut-on skipper le lab Git ?
Non — sans livrable versionné, pas de preuve d’apprentissage.

Langages autres que Python ?
Oui — adaptez runner de tests.

Vs Claude Code refactor ?
Même discipline.

Couverture 100% ?
Non ; filet utile > perfection.

Lien GitHub PR ?
codex-github.

Points clés

• Tests avant refactor
• Plan validé
• Diffs petits
• Abort hors scope
• DoD tests+revue

Pour aller plus loin / Suite

1. GitHub · Slash
2. Workflows agents · Intro
3. /ia/

Maillage série IA Outils 2026

• Hub : /tutoriels/ia-parcours-devops-2026/ · /ia/
• Sécurité : prompt injection

• seo_title : Codex refactor tests DevOps | Elastic Hayway
• seo_desc : Pilotez Codex pour refactorer avec filet de tests et diffs minimaux — tutoriel FR.
• focus : Codex refactor tests

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.

Mesure et amélioration continue

Définissez trois indicateurs simples : taux de DoD vert du premier coup, nombre de refus utiles par session, coût tokens par livrable Git accepté. Revoyez-les toutes les deux semaines. Si le taux DoD stagne sous 50 %, le problème est le brief ou le corpus de rules, pas « le besoin d’un modèle plus cher ». Si le coût explose, imposez un modèle fast par défaut et réservez strong aux plans. Publiez un mini tableau dans le dépôt docs pour rendre le coût visible à l’équipe, comme n’importe quelle ligne cloud.