Le cycle de session : 8 commandes qui transforment le codage IA en système

56 commandes sont les ingrédients. Ceci est la recette.

La plupart des développeurs installent un ensemble de templates de codage IA et voient une liste d’options. Ils en choisissent un, l’utilisent, ferment la session. C’est comme acheter un abonnement à la salle de sport et n’utiliser que la fontaine à eau.

La vraie puissance, c’est le cycle de session : une boucle répétable de 8 commandes qui transforme chaque session de codage en progrès cumulatif. C’est le workflow exact utilisé pour construire un site web multilingue de 97 pages, un ebook PDF en 4 langues et un outil CLI open source, le tout avec l’IA aux commandes.

La boucle

Chaque session de codage IA productive suit la même structure :

1. Reprendre (/read-handover). Reprendre là où la dernière session s’est arrêtée. La session précédente a sauvegardé un HANDOVER.md contenant le travail accompli, les décisions prises, les alternatives rejetées et les prochaines étapes exactes. L’IA absorbe tout cela avant de toucher à quoi que ce soit.

2. Prioriser (/strategic-next). Avant de faire quoi que ce soit, déterminer le travail à plus fort impact. Lancer un audit complet du projet, explorer les opportunités, les évaluer sur une matrice Impact/Effort. Construire ce qui compte, pas ce qui semble urgent.

3. Explorer (/creative-brainstorm). Une fois que vous savez QUOI construire, explorez le COMMENT. Reformulez le problème de plusieurs façons. Générez des idées à travers différents prismes : inversez, supprimez, simplifiez, poussez à l’extrême. Convergez vers la meilleure approche. Évitez le piège de la première idée.

Ensuite, on construit, avec le bon template selon le travail : /feature-build pour les fonctionnalités, /quick-task pour les petits changements, /debug-rootcause pour les bugs. Les phases de planification ont déjà fixé la direction. L’exécution, c’est les 20%.

4. Vérifier la logique (/verify-thorough). Cinq couches de vérification : logique (est-ce cohérent ?), contextuelle (est-ce adapté au système ?), complétude (tous les chemins sont couverts ?), empirique (exécutez-le vraiment), régression (est-ce que quelque chose est cassé ?). « Ça a l’air correct » n’est pas une vérification.

5. Vérifier visuellement (/visual-verify). La logique détecte les bugs fonctionnels. La vérification visuelle détecte tout le reste : le responsive sur desktop, tablette et mobile. Les erreurs console. Les échecs réseau. Les tests d’interaction. Les captures d’écran comme preuve.

6. Auditer les standards (/principles-check). Une fois que le code fonctionne et a la bonne apparence, vérifiez-le par rapport à vos principes d’ingénierie. KISS, DRY, YAGNI, SRP, sécurité, tests, documentation. Chaque violation reçoit une citation exacte fichier:ligne.

7. Nettoyer (/housekeeping). Précision de la documentation. Suppression du code mort. Audit des dépendances. Hygiène Git. Consolidation. Laissez la base de code en meilleur état que vous ne l’avez trouvée.

8. Sauvegarder l’état (/low-context-handover). Sauvegardez tout : ce qui s’est passé, ce qui est terminé, ce qui est en cours, les décisions et alternatives rejetées, les problèmes connus, les prochaines étapes exactes. Cela reconnecte à l’étape 1 de la session suivante. La boucle est bouclée.

Huit commandes. Une boucle. Chaque session.

Pourquoi chaque étape compte

Les étapes ne sont pas arbitraires. Chacune prévient un mode de défaillance spécifique.

Sans handovers, chaque session gaspille 10 à 20 minutes à rétablir le contexte. Sur 50 sessions, cela représente 8 à 16 heures perdues en redécouverte.

Sans planification stratégique, vous dérivez. Vous corrigez des bugs de faible priorité pendant que des fonctionnalités critiques restent non construites. Vous optimisez le CSS pendant que le flux de paiement est cassé.

Sans brainstorming, vous construisez la première chose qui vous vient à l’esprit, puis vous la refactorisez plus tard alors qu’une approche plus simple existait depuis le début.

Sans double vérification, vous livrez du code qui fonctionne en démo et casse en production. Ou qui fonctionne parfaitement mais apparaît cassé sur mobile. Le fossé de vérification de 48% (Sonar, 2026) est là où vivent les bugs.

Sans audits de principes, votre base de code accumule lentement les exceptions « juste cette fois » jusqu’à ce que vos standards ne soient plus qu’un souvenir.

Sans housekeeping, le désordre s’accumule. Les docs obsolètes induisent en erreur. Les fichiers morts sèment la confusion.

Chaque étape est un filet de sécurité. Ensemble, elles forment un système où rien ne passe entre les mailles.

Le multiplicateur de parallélisme

La boucle est puissante pour un seul projet. Elle devient un multiplicateur de force quand vous gérez plusieurs projets simultanément.

Un projet par IDE. Un IDE par session Claude Code. Plusieurs IDEs ouverts en même temps :

• IDE 1 : Construction d’un site web
• IDE 2 : Rédaction d’un ebook
• IDE 3 : Développement d’un outil CLI
• IDE 4 : Préparation de contenu marketing

Chaque projet exécute son propre cycle de vie. Chacun produit son propre handover. Quand vous revenez à un projet, /read-handover reprend exactement là où vous vous êtes arrêté. Le système de handovers permet de jongler avec dix projets sans perdre le contexte dans aucun d’entre eux.

Sans handovers, chaque changement de projet signifie rétablir le contexte à chaque fois. Avec les handovers, l’IA reprend le fil en quelques secondes. Le cycle de session est le même dans chaque projet, donc la charge cognitive du changement est quasi nulle.

Commencez simple, ajoutez des couches

Vous n’avez pas besoin des 8 commandes dès le premier jour.

Semaine 1. Commencez avec /kickoff et /low-context-handover. Commencez et terminez simplement les sessions correctement. Cela seul vous place en avance.

Semaine 3. Ajoutez /read-handover et /verify-thorough. Maintenant vous préservez le contexte entre les sessions et attrapez les bugs avant qu’ils ne soient livrés.

Mois 2. Ajoutez /strategic-next et /visual-verify. Maintenant vous construisez les bonnes choses et prouvez qu’elles fonctionnent visuellement.

Mois 4. La boucle complète de 8 commandes plus le parallélisme sur plusieurs IDEs.

Cette progression reflète le système de ceintures des arts martiaux. Vous développez la mémoire musculaire à chaque niveau avant d’ajouter la couche suivante.

L’effet cumulatif

Chaque commande est utile seule. Ensemble, elles se cumulent.

Les handovers éliminent la perte de contexte, donc les décisions persistent entre les sessions. La planification stratégique empêche la dérive, donc vous construisez ce qui compte. Le brainstorming empêche le biais de la première idée, donc vous construisez de la bonne façon. La double vérification attrape les bugs tôt, donc il y a moins de débogage plus tard. Les audits de principes empêchent la dégradation, donc la base de code reste propre. Le housekeeping empêche le désordre, donc la base de code reste navigable. Le parallélisme multiplie le débit.

Après 50 sessions avec cette boucle, vous avez construit l’équivalent de ce qui prendrait plusieurs mois à une petite équipe. Non pas parce que l’IA écrit du code plus vite, mais parce que vous ne perdez jamais le contexte, ne construisez jamais la mauvaise chose et ne livrez jamais du travail non vérifié.

C’est la méthodologie. Pas une collection de templates. Une boucle, exécutée de manière cohérente, se cumulant dans le temps.

Les outils pour exécuter ce workflow sont gratuits et open source. Installez-les avec npx @ccprompt/cli install-generic . et commencez avec /kickoff. La méthodologie complète explique les principes derrière chaque étape.