Dans le premier article de cette série, nous avons expliqué comment préparer un ordinateur pour le vibe coding. Nous avons installé Linux, configuré Codex et Antigravity, connecté GitHub et publié notre première application avec Railway.
Nous avons réussi à développer une petite application grâce à l'intelligence artificielle sans écrire nous-mêmes le code.
Mais ce n'était qu'un essai. Nous avons demandé à Codex de programmer, vérifié que cela fonctionnait, puis utilisé Antigravity pour contrôler le résultat. C'est bien pour commencer, mais pour travailler sur de vrais projets, il nous faut une organisation plus solide.
Que se passe-t-il lorsque plusieurs fonctionnalités attendent d'être développées ? Comment empêcher l'IA de modifier des fichiers qu'elle ne devrait pas toucher ? Qui vérifie qu'une solution est bien conçue avant de la programmer ? Et comment savoir si ce qui a été publié correspond exactement à ce que nous avons contrôlé ?
Pour répondre à ces questions, j'ai progressivement construit ma propre méthode de travail. Je n'ai rien inventé de révolutionnaire : j'ai adapté les pratiques courantes du développement professionnel à un environnement où des agents d'intelligence artificielle effectuent une grande partie du travail.
Je vais t'expliquer comment l'organiser et l'utiliser étape par étape, au cas où cela t'aiderait à la reproduire.
Comment j'organise le travail avec des agents IA
L'idée est simple : une IA développe et une autre audite son travail, tandis que nous gardons le contrôle des décisions importantes.
Dans mon cas, j'utilise cinq outils de base :
| Outil | Fonction |
| Codex | Analyse, planifie, programme, teste et documente. |
| Antigravity | Audite indépendamment le plan et le code. |
| GitHub | Conserve le code, les versions et les pull requests. |
| Linear | Organise les tâches, les tests, les audits et les statuts. |
| Notion | Conserve les exigences, les décisions et l'historique du projet. |
J'en ajoute deux autres : Local WP pour les développements WordPress et Convex ou Supabase lorsqu'une application web a besoin d'une base de données.
Notion est facultatif, mais je le recommande pour les projets de taille moyenne. Nous verrons pourquoi plus loin.
Nous ne sommes pas non plus obligés d'utiliser ces mêmes applications. Nous pouvons par exemple remplacer Codex par Claude Code ou choisir un autre agent comme auditeur. L'essentiel est de séparer les responsabilités.
La procédure complète est la suivante :
- Exigences.
- Plan technique.
- Premier audit.
- Développement et tests.
- Deuxième audit.
- GitHub.
- Déploiement.
- Vérification.
Les étapes 2 (Codex) et 3 (Antigravity) peuvent être répétées plusieurs fois : si Antigravity détecte un problème, Codex le corrige et nous recommençons la vérification. L'idée est d'avancer par cycles de travail et de contrôle, sans passer à la phase suivante tant que des problèmes importants restent sans solution.
Dans ma méthode, deux audits sont obligatoires, même si leur profondeur dépend de la complexité du développement. Le premier examine ce que nous allons faire et le second vérifie ce que nous avons réellement fait.
Et un point important : un GO de l'auditeur ne vaut pas autorisation de publier. Cette décision nous appartient toujours.
Étape 1. Préparer notre environnement de travail avec Codex
Nous partons de l'ordinateur configuré dans le premier tutoriel. Codex, Antigravity et GitHub fonctionnent déjà, nous n'allons donc pas refaire les installations.
Ouvrons un terminal dans le dossier de notre projet et lançons Codex :
cd ~/Proyectos/mi-proyecto
codex
Voici maintenant l'un des aspects que je préfère dans le travail avec des agents : nous n'avons pas besoin de configurer manuellement toute la structure du projet. Nous pouvons demander à Codex de le faire.
Prompt 1. Configurer l'environnement de travail
Je veux préparer ce projet pour travailler selon une procédure de développement supervisée par IA.
Tu joueras le rôle d'analyste et de développeur. Antigravity sera l'auditeur indépendant. Nous utiliserons GitHub pour le code, Linear pour les tâches et, éventuellement, Notion pour la documentation.
Inspecte le projet et vérifie les connexions disponibles. Propose les instructions permanentes, la documentation minimale, les règles d'autorisation et une procédure comprenant deux audits obligatoires : celui du plan technique et celui du code.
Les implémentations, les opérations Git importantes et les déploiements nécessitent une autorisation humaine. Les tâches ne sont clôturées qu'après vérification en production.
Présente d'abord un plan de configuration. Ne crée aucun fichier et ne modifie aucun service avant d'avoir reçu une autorisation.
Codex devrait analyser ce dont nous disposons et nous indiquer ce qui manque.
Certaines opérations devront généralement être réalisées personnellement :
- Se connecter à Linear ou à Notion.
- Autoriser une intégration.
- Accepter des autorisations ou établir une connexion qui nécessite une authentification dans le navigateur.
TRÈS IMPORTANT : nous ne devons pas lui donner de mots de passe ni de jetons en les collant directement dans le chat.
Nous utiliserons les mécanismes d'authentification propres à chaque service (GitHub et Cloudflare en disposent) et n'accorderons que les autorisations nécessaires.
Une fois la configuration approuvée, Codex pourra préparer les fichiers et organiser les outils.
Mais nous vérifierons qu'il l'a réellement fait, donc nous lui demanderons de le contrôler. Un agent ne peut pas établir de connexion avec Linear si son environnement ne dispose pas d'une intégration compatible.
Étape 2. Organiser la documentation sans remplir le dépôt de fichiers
Pour travailler avec des agents, nous avons besoin de quelque chose que les conversations ne fournissent pas à elles seules : une mémoire opérationnelle du projet.
Imaginons que nous développions depuis plusieurs semaines et que nous ouvrions une nouvelle session Codex. Nous ne voulons pas réexpliquer toute l'architecture, les outils utilisés, les fichiers qu'il peut modifier et le fonctionnement du déploiement.
Pour éviter cela, nous utiliserons deux documents essentiels dans le dépôt :
- AGENTS.md : instructions permanentes pour Codex, limites de ses interventions et règles de développement.
- PROJECT.md : description du projet, architecture de base, environnements et liens vers la documentation.
Codex peut les créer à partir de nos exigences.
Et pourquoi avons-nous besoin de Notion ?
Pour les petits projets, les fichiers Markdown peuvent suffire à documenter les changements et les décisions. Mais à mesure que les fonctionnalités, les décisions, les exigences et les modifications d'architecture s'accumulent, nous finissons avec trop de documents dans le dépôt.
C'est pourquoi je recommande Notion pour les projets de taille moyenne.
Nous y conserverons principalement les PRD (Product Requirements Document), les décisions techniques et l'historique du projet. Linear suivra les tâches, leurs statuts, les audits et les tests. GitHub conservera le code.
Ce qui est intéressant, c'est que Notion et Linear seront principalement utilisés par les agents eux-mêmes. Codex rédigera et actualisera la documentation, consultera les exigences avant de programmer et enregistrera les résultats. Antigravity devra lire ces informations pour réaliser ses audits.
Nous n'aurons pas à écrire manuellement des pages et des pages de documentation. Notre responsabilité sera de vérifier que les exigences et les décisions importantes correspondent à ce que nous voulons.
Étape 3. Définir ce que nous voulons développer
Prenons comme exemple une fonctionnalité réelle que j'ai développée pour ce site.
Sur mon magazine, les pages d'étiquettes affichaient les publications dans l'ordre chronologique. Je voulais les améliorer pour mettre en avant les contenus les plus intéressants sans perdre la liste habituelle.
C'est le genre de besoin que nous pouvons expliquer à Codex en langage naturel, tout en sachant qu'une demande de ce type laisse beaucoup de questions ouvertes.
- Combien d'articles mettons-nous en avant ?
- Comment décidons-nous lesquels sont pertinents ?
- Que deviennent les autres ?
- Cela doit-il fonctionner sur toutes les pages ?
- Quels éléments ne voulons-nous pas modifier ?
Avant d'analyser quoi que ce soit, mieux vaut résoudre ces questions.
Prompt 2. Préparer les exigences et le plan technique
Je souhaite développer cette fonctionnalité : [DESCRIPTION].
Lis les instructions et la documentation du projet. Transforme le besoin en exigences vérifiables et en critères d'acceptation. Prépare ou mets à jour le PRD et organise les tâches nécessaires dans Linear.
Examine le code existant et propose la solution la plus simple qui répond aux exigences, en identifiant les fichiers concernés, les risques, les alternatives et les tests.
Ne programme pas encore. Pose-moi les questions fonctionnelles auxquelles les informations disponibles ne permettent pas de répondre et prépare le plan pour un audit indépendant.
C'est l'un des changements les plus importants par rapport au fait de demander simplement à une IA de programmer quelque chose.
Codex peut nous aider à transformer une idée en spécification. À nous de décider si cette spécification répond à notre besoin.
Dans le cas des pages d'étiquettes, par exemple, les critères d'acceptation ne pouvaient pas se limiter à l'affichage des articles mis en avant. Il fallait aussi préserver la navigation, éviter les doublons indésirables et garantir le bon fonctionnement sur les différentes pages.
Une fois l'approche approuvée, Codex l'enregistre et prépare le plan technique.
Nous n'avons encore écrit aucune ligne de code.
Conception du front-end
Dans ce cas, je savais très précisément quel design je voulais, donc je n'ai pas demandé de propositions visuelles. En revanche, dans d'autres situations, j'en demanderais à ce stade, afin qu'elles soient prises en compte avant qu'on me propose la solution technique.
Évidemment, si tu sais ce que tu veux, tu l'expliques et voilà. Ou, si la fonctionnalité touche le back-end et non le front-end, tu n'auras pas non plus besoin de maquettes.
Étape 4. Premier audit : vérifier le plan avec Antigravity
C'est maintenant au tour de notre deuxième agent d'intervenir.
Ouvrons un autre terminal dans le même dossier du projet et exécutons :
agy
Dans ma procédure actuelle, Antigravity fonctionne manuellement. Nous ne laissons pas Codex l'appeler automatiquement et poursuivre sans que nous ayons examiné le résultat.
Nous voulons qu'il agisse comme un auditeur indépendant, pas comme un autre programmeur qui se met à modifier des fichiers.
Prompt 3. Auditer le plan technique
Agis exclusivement en tant qu'auditeur technique indépendant.
Examine les instructions du projet, les exigences et le plan proposé par Codex. Évalue si la solution est viable, suffisamment simple, sûre et compatible avec le fonctionnement existant.
Vérifie les risques, les régressions possibles et la pertinence des tests prévus.
Rends un verdict motivé : GO, GO conditionnel ou NO-GO. Si tu ne disposes pas de preuves suffisantes, indique-le expressément.
Identifie les problèmes concrets et les corrections nécessaires. Ne modifie aucun fichier.
Pourquoi auditer avant de développer ?
Parce qu'une solution peut être parfaitement programmée et rester une mauvaise solution.
Elle introduit peut-être une dépendance inutile, duplique des informations existantes, effectue trop de requêtes ou complique la maintenance future.
Avec les pages d'étiquettes, par exemple, il ne suffisait pas de créer un système de mise en avant. Il fallait aussi déterminer comment calculer l'ordre sans lancer des opérations lentes chaque fois qu'une personne consultait une page.
Si l'auditeur identifie des problèmes, nous transmettons son rapport à Codex. Celui-ci révise le plan et nous recommençons l'audit si nécessaire.
On ne commence pas à programmer tant que le plan n'est pas accepté et qu'une autorisation humaine n'a pas été donnée pour l'implémenter.
Étape 5. Codex développe et effectue les tests
Une fois le plan approuvé, l'implémentation commence.
Codex travaillera sur une branche du dépôt. Si tu as déjà lu le premier volet, tu connais Git et GitHub, donc inutile de répéter leur fonctionnement.
La nouveauté, c'est que nous ne programmons pas directement sur la version stable du projet. Nous préparons les modifications séparément afin de pouvoir les examiner avant de les intégrer.
Prompt 4. Implémenter la fonctionnalité
J'autorise le développement du plan approuvé et audité correspondant à [TÂCHE LINEAR].
Travaille sur une branche dédiée et limite les modifications au périmètre autorisé.
Implémente la solution, exécute les tests pertinents et vérifie les régressions possibles. Documente les résultats dans Linear.
Prépare le diff complet, identifie les fichiers modifiés et fournis les preuves nécessaires au deuxième audit.
Ne réalise aucun merge ni déploiement. Arrête-toi lorsque le développement est prêt à être examiné.
Codex peut modifier les fichiers, exécuter les tests et corriger les erreurs dans le périmètre que nous avons approuvé.
Mais il faut surveiller une chose : ce n'est pas parce que l'IA affirme qu'une fonctionnalité marche que cela a été vérifié.
Il nous faut des preuves. Selon le projet, il peut s'agir de tests automatisés, de résultats d'exécution, de vérifications fonctionnelles ou d'une combinaison de ces éléments.
Il faut également distinguer ce que Codex a testé de ce qu'il ne peut pas encore vérifier.
Reprenons notre exemple : il ne suffit pas de constater que trois articles sont mis en avant. Il faut vérifier ce qui se passe lorsqu'il y a moins d'articles disponibles, lorsqu'on change de page ou lorsqu'un contenu ne possède pas les données attendues, par exemple un article non traduit dans une langue.
L'agent doit consigner ces vérifications et leurs éventuelles limites.
Étape 6. Deuxième audit : examiner le code réel
La fonctionnalité est développée, mais nous n'allons pas encore la publier.
Nous revenons à Antigravity et lui demandons d'examiner le code modifié, et pas simplement le rapport préparé par Codex.
Prompt 5. Auditer l'implémentation
Agis comme auditeur technique indépendant pour [TÂCHE LINEAR].
Examine le diff complet, le plan approuvé, les exigences et les preuves des tests.
Recherche les défauts fonctionnels, les problèmes de sécurité, les régressions, la complexité inutile et les modifications hors du périmètre autorisé.
Rends un verdict motivé et précise, si possible, les problèmes par fichier et emplacement.
Enregistre l'empreinte SHA-256 du diff audité pour identifier précisément la version examinée.
Ne modifie aucun fichier et n'autorise aucun commit, merge ou déploiement.
Deux détails sont importants.
Premièrement, Antigravity doit pouvoir consulter les mêmes règles et exigences que Codex. Sinon, il risque de valider une solution techniquement correcte qui ne répond pas à notre demande.
Deuxièmement, il faut conserver la documentation de l'ensemble des modifications auditées. Nous pouvons ainsi identifier la version exacte qui a reçu le GO et détecter si le code a été modifié ensuite. Cette empreinte doit être calculée de manière reproductible sur un contenu identique.
Dans mon cas, nous conservons l'ensemble du dossier dans Linear, associé à la tâche correspondante.
Si Antigravity détecte des erreurs, nous retournons vers Codex, demandons les corrections et recommençons l'audit.
Deux agents peuvent se tromper, même lorsqu'ils partagent le même avis. Les audits sont donc des contrôles supplémentaires, pas des garanties absolues. Et c'est pourquoi nous pourrons éventuellement en ajouter un troisième.
Étape 7. Intégrer les modifications dans GitHub
Une fois le GO obtenu, nous pouvons préparer l'intégration. La procédure habituelle est la suivante :
Branche > Commit > Push > Pull Request > Merge.
Nous n'avons pas besoin d'exécuter ces commandes à la main. Codex peut s'en charger, mais nous devons comprendre ce que nous autorisons.
La pull request nous permet d'examiner les modifications à intégrer dans la branche principale, les tests correspondants et les recommandations de l'auditeur.
Il convient également de vérifier que la version à intégrer est toujours celle qui a été auditée. Si nous modifions le code après avoir obtenu un GO, ce verdict risque de ne plus être valable.
Je préfère des autorisations explicites pour les opérations importantes. Nous pouvons en regrouper certaines lorsque le périmètre est très clair, mais pas donner carte blanche pour fusionner et publier.
Que l'auditeur juge le développement correct est une chose ; que nous décidions de l'intégrer en est une autre.
C'est ici qu'une troisième IA pourrait intervenir : nous pouvons ajouter un deuxième auditeur spécialisé, comme CodeRabbit.
Contrairement à Antigravity, que nous utilisons pour vérifier localement le plan et le code, CodeRabbit peut analyser automatiquement les pull requests GitHub avant leur fusion.
Cette vérification supplémentaire est intéressante pour les projets importants, même si elle n'est pas indispensable et reste payante, à un tarif toutefois modeste au regard de son apport. Pour l'instant, je préfère conserver les deux audits manuels et envisager ce troisième contrôle lorsque le projet prendra de l'ampleur.
Étape 8. Déployer et vérifier le fonctionnement en production
Cette étape dépend beaucoup de l'hébergement du projet.
Dans le premier volet, nous avons utilisé Railway. Nous pourrions également déployer avec GitHub Actions, les outils de notre hébergeur ou n'importe quel autre système de déploiement.
Nous aborderons les particularités de WordPress, LocalWP et Webempresa dans un autre article.
Ici, une règle générale nous intéresse : un déploiement réussi ne signifie pas que la fonctionnalité fonctionne correctement.
Une fois la modification publiée, nous devons vérifier l'application réelle.
Dans notre exemple, cela signifie visiter les pages publiques, vérifier les articles mis en avant, parcourir la liste et nous assurer que nous n'avons pas perturbé d'autres fonctionnalités.
Il faut aussi confirmer que la nouvelle version s'affiche. Parfois, le code est correctement déployé, mais un cache continue de servir l'ancien contenu, comme cela m'est arrivé avec WP Rocket.
Pour les développements importants, nous devons prévoir comment restaurer la version stable si quelque chose se passe mal.
Ce n'est qu'après ces vérifications que nous pouvons affirmer que la fonctionnalité est terminée.
Étape 9. Clôturer la tâche et préparer le développement suivant
Une fois le résultat vérifié, nous demandons à Codex de mettre à jour Linear et la documentation du projet.
Il doit enregistrer ce qui a été développé, la version publiée, les tests effectués et les éventuels incidents en attente.
La tâche est considérée comme terminée après sa vérification en production, pas lorsque Codex finit de programmer ni lorsque Antigravity donne son GO.
Cette documentation offre un autre avantage : nous pouvons terminer la session et en commencer une nouvelle sans perdre le contexte.
D'ailleurs, je le recommande lorsque nous commençons une fonctionnalité différente. Les agents peuvent retrouver les règles, les exigences et les décisions dans les documents du projet, au lieu de dépendre de conversations interminables.
Avec le temps, nous pourrons automatiser une partie de la coordination entre Codex et Antigravity. Pour l'instant, je préfère la garder manuelle, vérifier que la procédure fonctionne et gagner en confiance avant de supprimer des étapes de supervision.
Cette façon de travailler vaut-elle la peine pour tous les développements ?
Non.
Pour créer un essai ou expérimenter pendant vingt minutes, préparer de la documentation, deux audits et une procédure de publication, c'est excessif.
Mais lorsque nous développons un véritable site web, une application pour un client ou un projet que nous entretiendrons pendant des mois, ce travail supplémentaire est parfaitement justifié.
L'avantage de cette procédure n'est pas d'éliminer les erreurs ni de remplacer les compétences en programmation, mais de travailler de façon plus structurée, de conserver les décisions et de détecter les problèmes avant qu'ils n'atteignent les utilisateurs. Nous réduisons les erreurs caractéristiques des premiers essais de vibe coding.
Et puisque les agents effectuent la plupart des tâches opérationnelles, notre intervention se concentre sur l'essentiel : décider ce que nous voulons, approuver la manière de le réaliser et vérifier que le résultat fonctionne.
Conclusion
Dans le premier article, nous avons préparé l'ordinateur. Dans celui-ci, nous avons préparé notre manière de travailler.
Nous savons maintenant comment :
- Transformer un besoin en exigences.
- Demander un plan à Codex.
- Le faire auditer par Antigravity.
- Développer une fonctionnalité.
- Examiner le code.
- Publier avec une gestion des versions.
- Tout documenter.
Il ne s'agit pas simplement de programmer plus vite grâce à l'intelligence artificielle, mais de pouvoir maintenir ce que nous développons, comprendre les modifications et disposer d'une procédure pour corriger les problèmes lorsqu'ils surviennent.
Dans le prochain volet, nous appliquerons cette méthode à WordPress : développement local, tests, fichiers versionnés et déploiements sur un véritable hébergement.
Questions fréquentes
Faut-il savoir programmer pour utiliser cette procédure ?
Il n'est pas indispensable d'écrire du code, mais il faut comprendre les concepts fondamentaux du développement et apprendre à interpréter les tests et les risques. L'IA ne nous décharge pas de notre responsabilité quant au résultat.
Dois-je obligatoirement utiliser Codex et Antigravity ?
Non. Tu peux les remplacer par d'autres agents de programmation et de vérification. L'essentiel est de séparer les rôles et d'éviter que le développeur soit le seul à évaluer son propre travail.
Ai-je besoin de Notion et de Linear ?
Linear est l'outil de gestion des tâches utilisé dans ce tutoriel. Notion est facultatif pour les projets simples, mais je le recommande lorsque les exigences, les décisions et les documents s'accumulent. Une autre solution consiste à conserver ces informations en Markdown.
Que faire lorsqu'Antigravity émet un NO-GO ?
Transmets le rapport à Codex, demande-lui de corriger les problèmes et recommence l'audit. Ne passe pas automatiquement à la phase suivante.
Pourquoi réaliser deux audits ?
Parce que le premier cherche les problèmes de conception et que le second vérifie l'implémentation. Examiner seulement le code peut laisser passer des erreurs de conception qu'il aurait été plus facile de corriger plus tôt.
Puis-je utiliser cette méthode avec WordPress ou d'autres technologies ?
Oui. La procédure est indépendante du langage ou de la plateforme. Seuls changent les tests, les environnements et les mécanismes de publication.
Quand une tâche est-elle réellement terminée ?
Lorsque la version autorisée a été publiée, que son fonctionnement a été vérifié en production et que les preuves et les décisions ont été consignées.

Laisser un commentaire