- Dans un environnement de développement collaboratif avec l’IA, les humains doivent définir clairement l’orientation du projet et les décisions à prendre pour maintenir la qualité
- Une documentation précise est nécessaire pour que l’IA comme les autres développeurs comprennent clairement les exigences et les contraintes
- Mettre en place un système de débogage et un processus de revue de code renforce la fiabilité du code généré par l’IA et son processus de validation
- Le marquage des fonctions à risque de sécurité, l’isolement des tests et des règles de linting strictes permettent d’assurer la stabilité et la cohérence du code
- Le découpage du travail en unités et la réduction de la complexité permettent de garder le contrôle sur la génération de code par l’IA tout en maximisant l’efficacité
1. Établir une vision claire
- Les humains comprennent le monde, l’équipe et le comportement des utilisateurs, mais l’IA n’ayant pas d’expérience, elle a besoin d’instructions explicites
- Dans un projet, toute décision non documentée finira par être prise par l’IA
- Il faut discuter à l’avance de l’architecture, des interfaces, des structures de données et des algorithmes, puis définir la manière de les tester
- Les décisions de long terme et difficiles à modifier doivent impérativement être gérées directement par des humains
2. Maintenir une documentation précise
- Pour que l’IA génère du code adapté à l’objectif, il est indispensable de lui transmettre des exigences détaillées
- Comme les autres développeurs doivent pouvoir fournir les mêmes informations à l’IA, il faut inclure dans le dépôt de code une documentation au format standardisé
- Y consigner en détail les exigences, contraintes, architecture, standards de codage, design patterns, etc.
- Utiliser des diagrammes UML, organigrammes et pseudocode pour représenter visuellement les structures complexes
3. Mettre en place un système de débogage qui aide l’IA
- Il faut prévoir un système de débogage efficace pour permettre à l’IA de vérifier rapidement le fonctionnement du code
- Exemple : collecter les logs de tous les nœuds d’un système distribué afin de fournir des informations résumées comme « les données ont bien été envoyées à tous les nœuds »
- Cela permet de réduire le coût d’exécution des commandes et d’accélérer l’identification des problèmes
4. Indiquer le niveau de revue du code
- Il faut différencier l’intensité de la revue selon l’importance du code
- Exemple : ajouter un commentaire
//A après une fonction écrite par l’IA pour indiquer si elle a été examinée par un humain
- Ce système facilite l’identification et la gestion du code non revu
5. Rédiger des spécifications de haut niveau et tester soi-même
- Pour faire passer les tests, l’IA peut tricher avec des objets simulés ou des valeurs codées en dur
- Pour l’éviter, il faut rédiger soi-même des tests basés sur les propriétés (property-based testing)
- Exemple : redémarrer le serveur et vérifier la cohérence des valeurs en base de données
- Le code de test doit être isolé dans une zone distincte afin que l’IA ne puisse pas le modifier
6. Séparer les tests d’interface
- Il faut faire en sorte que l’IA écrive les tests d’interface sans connaître le reste du contexte du code
- Les tests restent ainsi objectifs, sans être influencés par l’IA qui a implémenté le code
- Ces tests doivent eux aussi être protégés pour empêcher toute modification arbitraire par l’IA
7. Des règles strictes de linting et de formatting
- Des règles cohérentes de style de code et de linting sont essentielles pour maintenir la qualité et détecter tôt les erreurs
- Elles permettent aussi bien à l’IA qu’aux humains de vérifier facilement la qualité du code
8. Utiliser des prompts d’agents de code selon le contexte
- Utiliser des fichiers de prompt propres au projet, comme
CLAUDE.md, permet de réduire le coût de compréhension initial pour l’IA
- En y incluant les standards de codage, design patterns et exigences, on améliore la qualité et l’efficacité de la génération de code par l’IA
9. Identifier et marquer les fonctions à risque de sécurité
- Les fonctions sensibles du point de vue de la sécurité, comme l’authentification, les autorisations ou le traitement des données, doivent être explicitement signalées
- Exemple : utiliser les commentaires
//HIGH-RISK-UNREVIEWED et //HIGH-RISK-REVIEWED
- Si l’IA modifie ces fonctions, il faut configurer le système pour que leur statut de revue change automatiquement
- Les développeurs doivent toujours vérifier que ce statut est correct
10. Réduire au minimum la complexité du code
- La moindre ligne de code inutile occupe de la place dans la fenêtre de contexte de l’IA et augmente les coûts
- Il faut conserver une structure aussi simple que possible pour améliorer la compréhension, tant pour l’IA que pour les humains
11. Explorer le problème par l’expérimentation et les prototypes
- Il est possible d’expérimenter différentes solutions en tirant parti du faible coût de la génération de code par l’IA
- Créer plusieurs prototypes à partir d’une spécification minimale permet d’explorer l’approche optimale
12. Éviter la génération massive sans discernement
- Les tâches complexes doivent être découpées en petites unités pour que l’IA les traite étape par étape
- Exemple : générer des fonctions ou des classes individuelles plutôt que l’ensemble du projet
- Il faut vérifier que chaque composant respecte les spécifications et,
si l’on perd le contrôle de la complexité du code, il faut ramener le projet à son état initial
Aucun commentaire pour le moment.