Pipeline CPG pour codage IA sans dette technique

Pipeline automatisée CPG pour un codage AI sécurisé

Claude a généré 47 fichiers et 1 900 lignes de code—y compris la refonte et la migration—en seulement 38 minutes. La vitesse de l'IA dépasse désormais la capacité humaine à effectuer des revues, entraînant une accumulation inévitable de dette technique sans mesures automatiques de sécurité.

La pipeline CPG résout ce problème : elle analyse chaque validation, fournit un contexte graphique du code avant la génération, et évalue les risques dans les pull requests. Elle transforme ainsi le codage impulsif par IA en un processus maîtrisé.

Principaux défis du codage IA non contrôlé

Une génération non vérifiée entraîne des problèmes récurrents :

• Duplication logique au lieu de modules partagés, augmentant le volume de code et les branches.
• Graphes d'appels invisibles : modifier un fichier impacte des dizaines de dépendances.
• Dérive de documentation : écarts entre texte et chiffres dans le code—détectés dans 14 cas lors d’un audit.

Architecture de la pipeline CPG

La pipeline utilise des hooks Claude Code sur cinq étapes :

• Début de session : instantané du projet—nombre de méthodes, nombre de fichiers, complexité cyclomatique moyenne.
• Traitement des prompts : extraction de contexte par classe (emplacement, complexité, appels entrants/sortants).
• Avertissements pré-modification : haut niveau de complexité, TODOs dans le fichier, points d’entrée publics.
• Analyse post-validation : évaluation de la qualité et du rayon de changement.
• Fin de session : analyse post-génération de la variation de complexité et de volume.

Détails de l’analyse des commits : commit_analysis.py

Le hook clé commit_analysis.py s’exécute après git commit :

• Vérifie la fraîcheur du CPG via hash de commit vs HEAD.
• Mise à jour incrémentale : gocpg update.
• Analyse de qualité : complexité cyclomatique, TODO/FIXME, code debug, méthodes obsolètes.
• Analyse d’impact : méthodes appelantes, interfaces d’accès.

Le modèle reçoit un rapport : « 4 fichiers modifiés, 12 méthodes affectées, complexité passée de 8 à 12, 8 appelants en danger ».

Avantages du contexte pré-génération

Le contexte CPG avant les prompts change le comportement du modèle. Sans lui : modifications aveugles. Avec lui : prise de conscience de la complexité (8), des appels (8 directs), des TODOs, des interfaces (CLI, pas REST).

Cela réduit les risques de compatibilité et améliore la précision de génération.

Hooks Git pour la fraîcheur du graphe

Le CPG se dégrade avec chaque validation. Les hooks post-commit, post-merge, post-checkout exécutent gocpg update en arrière-plan :

• Analyse complète : 85 secondes.
• Mise à jour incrémentale pour 2 fichiers : 2 à 5 secondes.
• Pour 10 à 20 fichiers : 5 à 12 secondes.

Le développeur n’attend pas—le graphe se met à jour en tâche de fond.

Intégration dans CI/CD

Dans CI : construction de GoCPG, restauration du cache, synchronisation depuis la branche principale, publication dans le commentaire PR + annotations SARIF.

Le relecteur voit :

• Nombre de fichiers modifiés et de nœuds du graphe.
• Taux de hits du cache.
• Risques et découvertes sécurité.

Claims_validator.py pour l’intégrité de la documentation

Le validateur scanne les fichiers Markdown pour les affirmations numériques (ex. « 95 gestionnaires »), les croise avec des requêtes SQL contre le CPG. Détecte les écarts en quelques secondes.

Étude de cas : validation des user stories

Tâche : vérifier la couverture de 83 stories sur 5 interfaces (CLI, REST, TUI, MCP, ACP).

IA a généré StoryValidationRunner (450 lignes, 39 tests—tous verts).

Premier passage : 0 couverture à cause de bugs (gestion des chemins Windows/Unix, mode interactif vs batch).

Après corrections : 46 complètes, 32 partielles, 2 introuvables, 3 non applicables.

Suivant : faux positifs dus aux regex (premier segment de chemin, mots manquants). Précision améliorée ; la métrique « couverture complète » est passée de 49 à 46—signe d’une meilleure exactitude.

Les tests unitaires ont manqué des problèmes réels du graphe.

Contrôles avancés dans la revue de code

La pipeline s’est élargie à 13 vérifications :

• Avertissements pour méthodes publiques (CLI/REST/MCP).
• Enregistrement de nouveaux gestionnaires.
• Dépendances inter-modules.
• Analyse du diff Git.
• CPG Go dédié.
• Validation des tests pour nouveaux fichiers.
• Analyse des appels transitifs.
• Delta de couverture des stories.

Historique de qualité stocké dans DuckDB

Instantanés post-analyse : méthodes, complexité, TODOs, code mort. Hebdomadairement : +46 méthodes, complexité stable, méthodes lourdes en baisse.

Points clés

• Le contexte CPG pré-génération réduit les erreurs avant que l’IA ne code.
• Les mises à jour incrémentales du graphe prennent quelques secondes.
• Les rapports automatisés PR concentrent les relectures sur les risques.
• La validation des chiffres dans la doc empêche la dérive factuelle.
• Les métriques qualité DuckDB révèlent les tendances du projet.

— Editorial Team