Conductor : l'outil qui va révolutionner ta façon de coder avec l'IA ?

INSTALLER CONDUCTOR EN 2 MINUTES

Conductor est une extension pour Gemini CLI, l'outil en ligne de commande de Google pour coder avec l'intelligence artificielle. Son but ? Résoudre le problème numéro un des développeurs qui utilisent l'IA : l'absence de contexte. Imagine un assistant qui ne se souvient de rien entre deux sessions. C'est exactement ce qui se passe aujourd'hui avec la plupart des Outils d'IA pour le code.

Pour installer Conductor, il faut d'abord avoir Gemini CLI sur ta machine. Si ce n'est pas déjà fait, ouvre ton terminal et lance cette commande :

# Installer Gemini CLI globalement
npm install -g @google/gemini-cli

# Vérifier que l'installation a fonctionné
 gemini --version

Si tu vois un numéro de version s'afficher, c'est bon . Sinon, vérifie que Node.js est bien installé sur ton ordinateur. Si tu rencontres des erreurs de permissions, utilise un gestionnaire de versions comme nvm au lieu de lancer les commandes en tant qu'administrateur.

Conductor a besoin d'un projet Git pour fonctionner correctement. Si tu démarres un nouveau projet, crée un dossier et initialise Git avec ces commandes :

# Créer un nouveau dossier pour le projet et s'y rendre
mkdir my-project && cd my-project

# Initialiser un dépôt Git
 git init

# Faire un premier commit vide
 git commit --allow-empty -m "Initial commit"

Ensuite, installe Conductor directement depuis GitHub :

# Installer l'extension Conductor
gemini extensions install https://github.com/gemini-cli-extensions/conductor

# Avec la mise à jour automatique (recommandé)
gemini extensions install https://github.com/gemini-cli-extensions/conductor --auto-update

COMMENT CONDUCTOR GARDE-T-IL TON CONTEXTE EN VIE ?

Contrairement aux assistants IA classiques qui repartent de zéro à chaque session, Conductor stocke toutes les informations importantes de ton projet dans des fichiers Markdown à l'intérieur d'un dossier appelé conductor/. Ce dossier contient six fichiers clés qui définissent ton projet :

conductor/
├── product.md                 # Vision du produit, utilisateurs, objectifs, fonctionnalités
├── product-guidelines.md      # Standards d'interface, ton de la voix, gestion des erreurs
├── tech-stack.md              # Langages, frameworks, bases de données, infrastructure
├── workflow.md                # Préférences de tests, stratégie de commits, protocoles
├── code_styleguides/          # Guides de style par langage (générés automatiquement)
│   ├── python.md
│   ├── typescript.md
│   └── .
└── tracks.md                  # Registre principal de toutes les tâches en cours

Par exemple, product.md répond à la question : « Qu'est-ce qu'on construit et pour qui ? ». tech-stack.md empêche l'IA de te proposer des bibliothèques ou des méthodes qui ne font pas partie de ton environnement. workflow.md te permet de définir si tu veux travailler en Test-Driven Development (TDD), quelle doit être ta stratégie de commits, et quelles vérifications manuelles sont nécessaires avant de passer à l'étape suivante.

Une fois que Conductor a analysé ton projet, il te suffit de committer le dossier conductor/ pour que tous les développeurs qui rejoignent le projet aient immédiatement accès au contexte complet :

# Ajouter le dossier Conductor au dépôt
 git add conductor/

# Faire un commit pour sauvegarder le contexte
 git commit -m "chore: initialize Conductor context-driven development"

CRÉER UNE NOUVELLE TÂCHE AVEC CONDUCTOR

Avec Conductor, chaque fonctionnalité ou correction de bug devient une track (une piste en français). Une track, c'est comme un mini-projet à l'intérieur de ton projet principal. Pour en créer une, utilise la commande :

/conductor:newTrack "Ajouter un bouton de mode sombre à la page des paramètres, en sauvegardant la préférence dans localStorage"

Conductor va alors générer trois fichiers dans un nouveau dossier conductor/tracks/ avec un identifiant unique basé sur la date, comme darkmode20260614 :

conductor/tracks/
└── darkmode20260614/
    ├── spec.md           # Ce qu'il faut faire et pourquoi (exigences, contraintes)
    ├── plan.md           # Liste détaillée des tâches à accomplir, organisées en phases
    └── metadata.json     # ID de la track, date de création, statut actuel

Le fichier spec.md contient la spécification de la fonctionnalité : quel problème elle résout, quels sont les objectifs, les exigences techniques, et surtout ce qui est hors scope. Cette dernière partie est cruciale : elle empêche l'IA de trop en faire et de s'éloigner de l'objectif initial.

Le fichier plan.md est une checklist d'implémentation organisée en phases. Pour notre exemple du mode sombre, ça pourrait ressembler à ça :

# Plan d'implémentation - Bouton de mode sombre

## Phase 1 : Fondations
- [ ] Tâche : Ajouter la clé theme au schéma localStorage et la documenter dans le README
- [ ] Tâche : Créer un hook useTheme qui lit/écrit la valeur theme et utilise par défaut la préférence système
- [ ] Tâche : Écrire des tests unitaires pour useTheme (comportement par défaut, lecture/écriture localStorage)
- [ ] Tâche : Vérification manuelle Conductor - Manuel utilisateur 'Fondations' (voir workflow.md)

## Phase 2 : Composant UI
- [ ] Tâche : Construire le composant ThemeToggle avec un bouton accessible (aria-label, support clavier)
- [ ] Tâche : Appliquer des classes CSS conditionnelles selon la valeur actuelle du thème
- [ ] Tâche : Écrire des tests de composant pour ThemeToggle (rend correctement, déclenche le toggle au clic)
- [ ] Tâche : Vérification manuelle Conductor - Manuel utilisateur 'Composant UI'

## Phase 3 : Intégration à la page des paramètres
- [ ] Tâche : Importer ThemeToggle dans le composant de la page des paramètres
- [ ] Tâche : Vérifier que la préférence persiste après un rafraîchissement de page et dans de nouveaux onglets
- [ ] Tâche : Écrire un test d'intégration pour la page des paramètres complète avec le mode sombre activé
- [ ] Tâche : Vérification manuelle Conductor - Manuel utilisateur 'Intégration page des paramètres'

LA MAGIE DE LA COMMANDE /conductor:implement

C'est ici que Conductor devient vraiment puissant. Une fois que tu as validé le plan dans plan.md, tu peux lancer :

/conductor:implement

Conductor va alors lire le plan et commencer à exécuter les tâches une par une. Pour chaque tâche terminée, il coche la case dans plan.md, crée un commit Git avec un message clair, et passe à la tâche suivante. Voici ce que tu pourrais voir dans ton historique Git après quelques minutes :

a3f9c12 feat(theme): write integration test for settings page dark mode
b7e2d45 feat(theme): import ThemeToggle into Settings page
c1a8f90 feat(theme): add accessible toggle button with aria-label
d4b3e21 feat(theme): create ThemeToggle component with conditional CSS
e5c6d78 test(theme): write unit tests for useTheme hook
f7d9a34 feat(theme): create useTheme hook with localStorage persistence

À la fin de chaque phase, Conductor s'arrête et te demande de vérifier manuellement que tout fonctionne comme prévu. C'est le principe de « preuve plutôt que promesse » : l'IA ne dit pas que ça marche, tu dois le confirmer avant de continuer. Si tu utilises le Test-Driven Development (comme défini dans workflow.md), Conductor suit automatiquement le cycle : écrire le test, vérifier qu'il échoue, implémenter le code, vérifier qu'il passe, puis passer à la tâche suivante.

Un des grands avantages de Conductor, c'est que son état est sauvegardé sur ton disque. Tu peux arrêter à tout moment, fermer ton ordinateur, revenir le lendemain ou changer de machine, et lancer à nouveau /conductor:implement. Il reprendra exactement là où il s'était arrêté, à la première tâche non cochée.

SUIVRE L'AVANCEMENT DE TON PROJET EN UN CLIN D'ŒIL

Pour savoir où tu en es dans tes différentes tracks, utilise la commande :

/conductor:status

Conductor va te donner un résumé clair de l'état de ton projet à un instant T :

Date/Heure actuelle : samedi 14 juin 2026
Statut du projet : 🟡 En cours

Tracks actives :
  * darkmode20260614 -- Phase 2 sur 3 | 7/12 tâches terminées (58%)
  * apiauth20260610  -- Phase 1 sur 4 | 3/5 tâches terminées (60%)

Prochaine action nécessaire :
  * Lancer /conductor:implement pour continuer darkmode20260614 (track actuelle)

Cette commande est parfaite pour reprendre le travail après une pause ou pour partager l'avancement avec ton équipe.

ANNULER UNE ERREUR GRÂCE À CONDUCTOR

Si quelque chose ne va pas et que tu dois revenir en arrière, Conductor te simplifie la vie. Contrairement à un simple git revert, Conductor comprend les unités logiques de travail : tracks, phases, tâches individuelles. Si tu veux annuler la dernière phase d'une track, il identifie les commits correspondants et les annule proprement. Il met aussi à jour plan.md pour décocher les tâches concernées, ce qui te permet de relancer /conductor:implement pour refaire le travail.

Imagine devoir annuler manuellement 11 fichiers modifiés sur 14 commits répartis sur trois phases : c'est un cauchemar. Conductor s'en charge pour toi et te fait gagner un temps précieux.

CONDUCTOR, L'EXPERT EN REVUE DE CODE QUI CONNAÎT TON PROJET PAR CŒUR

Avant d'ouvrir une pull request, tu peux demander à Conductor de faire une revue de qualité sur ton code implémenté. Il compare ce qui a été fait avec ce qui était prévu dans plan.md et product-guidelines.md. Il vérifie notamment :

• Les écarts entre la spécification et l'implémentation
• Les violations des guidelines du produit (gestion des erreurs incohérente, attributs d'accessibilité manquants, violations des styles)

C'est comme si tu avais un relecteur humain qui a lu toute ta spécification produit et sait exactement ce que la fonctionnalité était censée faire. Le résultat est un rapport de revue que tu peux corriger avant de fusionner le code.

CONDUCTOR POUR LES PROJETS EXISTANTS : UNE SOLUTION POUR TOUS

Conductor ne fonctionne pas seulement pour les nouveaux projets. Si tu l'utilises sur un projet existant (on appelle ça un brownfield project), il analyse automatiquement ton codebase pour en déduire ton stack technique et ton architecture. Il respecte tes fichiers .gitignore et .geminiignore pour éviter de traiter des dossiers lourds comme node_modules ou __pycache__.

Quand tu lances /conductor:setup sur un projet existant, il te pose des questions pour compléter les informations manquantes et génère le dossier conductor/ avec tout le contexte nécessaire. C'est une solution clé en main pour intégrer Conductor dans n'importe quel projet, quel que soit son âge ou sa complexité.

LES TROIS COMMANDES QUI FONT TOUT LE TRAVAIL

Conductor repose sur six commandes principales, mais trois d'entre elles couvrent l'essentiel du workflow :

• setup : Initialise le contexte du projet en analysant ton codebase et en créant les fichiers nécessaires dans le dossier conductor/.
• newTrack : Crée une nouvelle track pour une fonctionnalité ou une correction de bug.
• implement : Lance l'implémentation de la track en cours en suivant le plan défini.
• status : Affiche l'état actuel de toutes les tracks actives.
• revert : Annule une phase ou une tâche spécifique.
• review : Effectue une revue de qualité sur le code implémenté.

Ces commandes transforment ton expérience de développement avec l'IA en quelque chose de structuré, prévisible et surtout efficace.

POURQUOI CONDUCTOR CHANGE LA DONNE POUR LES DÉVELOPPEURS ?

Avant Conductor, coder avec l'IA ressemblait à ceci : tu décris une fonctionnalité, l'IA génère du code, mais comme elle ne connaît ni ton architecture, ni tes standards, ni tes objectifs, elle fait des suppositions plausibles. Certaines sont justes, beaucoup sont fausses. Résultat : tu passes plus de temps à déboguer le code généré qu'à coder toi-même.

Avec Conductor, l'IA a accès à tout le contexte de ton projet dès qu'elle commence à travailler. Elle connaît tes choix techniques, tes guidelines, tes objectifs produits. Elle ne part plus de zéro à chaque session. C'est comme si tu avais un assistant qui a lu ton livre de règles avant de commencer à coder.

Et le plus beau ? Conductor ne vit pas dans une fenêtre de chat éphémère. Tout est stocké dans des fichiers Markdown à côté de ton code, ce qui signifie que ton contexte voyage avec ton projet, pas avec ta session de chat.

CONDUCTOR ET LES COÛTS DE TOKENS : UN TRADE-OFF À CONNAÎTRE

Le principal inconvénient de Conductor, c'est qu'il lit tes fichiers de contexte à chaque commande. Pour les gros projets, surtout pendant la phase de setup et de planification, cela peut augmenter significativement l'utilisation de tokens. Vérifie toujours la consommation actuelle de ta session avec :

# Vérifier l'utilisation des tokens dans la session actuelle

C'est le prix à payer pour avoir un contexte toujours à jour et éviter de répéter les mêmes informations à chaque session.

CE QUE DEVIENT TON CODE APRÈS UNE TRACK TERMINÉE

Une fois qu'une track est terminée et que toutes les tâches sont cochées, Conductor te propose de l'archiver. Cela déplace le dossier de la track (par exemple conductor/tracks/darkmode20260614/) dans un sous-dossier archive/ et met à jour le fichier tracks.md pour marquer la track comme terminée. Ton historique Git conserve l'intégralité de l'implémentation, mais ton espace de travail reste organisé et propre.

CONDUCTOR DANS LA PRATIQUE : UN EXEMPLE CONCRET

Prenons un exemple simple : ajouter un bouton de mode sombre à une application web. Voici comment Conductor guide le processus :

1. Setup initial : Tu lances /conductor:setup dans ton projet. Conductor analyse ton codebase, te pose quelques questions sur ton stack technique et tes objectifs, puis génère le dossier conductor/ avec tous les fichiers nécessaires.
2. Création de la track : Tu décris la fonctionnalité souhaitée avec /conductor:newTrack. Conductor crée la track darkmode20260614 avec les fichiers spec.md et plan.md.
3. Validation du plan : Tu vérifies le plan dans plan.md et tu corriges ce qui ne va pas. C'est le moment de changer l'ordre des tâches ou d'en ajouter.
4. Implémentation : Tu lances /conductor:implement. Conductor commence à coder, commit après commit, en suivant le plan à la lettre.
5. Vérification manuelle : À la fin de chaque phase, Conductor s'arrête et te demande de vérifier que tout fonctionne. Tu testes le bouton de mode sombre, tu vérifies l'accessibilité, tu confirmes que la préférence persiste.
6. Archivage : Une fois la track terminée, Conductor l'archivage et met à jour tracks.md.

Résultat : une fonctionnalité propre, bien testée, conforme à tes standards, et un historique Git clair qui raconte l'histoire de son développement.

CONDUCTOR EST-IL FAIT POUR TOI ?

Conductor s'adresse surtout aux développeurs qui :

• Utilisent souvent l'IA pour coder et se retrouvent à corriger des erreurs de contexte.
• Veulent structurer leur processus de développement sans perdre en flexibilité.
• Travaillent en équipe et ont besoin d'un contexte partagé et persistant.
• Souhaitent automatiser une partie de la planification et de la revue de code.

Si tu fais partie de ces profils, Conductor pourrait bien devenir ton nouvel outil indispensable. Et si tu débutes en développement, il t'apprendra une méthodologie rigoureuse pour aborder tes projets avec l'IA.

COMMENT DÉMARRER AVEC CONDUCTOR ?

Tu es prêt à essayer Conductor ? Voici les étapes à suivre :

1. Installe Gemini CLI si ce n'est pas déjà fait :

npm install -g @google/gemini-cli
 gemini --version

2. Initialise un dépôt Git pour ton projet :

mkdir mon-projet && cd mon-projet
 git init
 git commit --allow-empty -m "Premier commit"

3. Installe Conductor :

gemini extensions install https://github.com/gemini-cli-extensions/conductor --auto-update

4. Lance la configuration pour créer le contexte de ton projet :

cd ton-projet
 gemini
 /conductor:setup

5. Crée ta première track et commence à coder avec l'IA comme jamais auparavant :

/conductor:newTrack "Ma première fonctionnalité"
 /conductor:implement

LE FUTUR DU DÉVELOPPEMENT AVEC L'IA

Conductor n'est pas juste un outil de plus dans la boîte à outils des développeurs. C'est une véritable révolution dans la façon dont on interagit avec l'IA pour coder. En rendant le contexte persistant et partagé, il transforme l'IA d'un simple générateur de code en un collaborateur fiable.

Avec des outils comme Conductor, l'IA ne sera plus jamais un simple copilote distrait, mais un véritable coéquipier qui connaît ton projet, tes règles, tes objectifs. Et ça, c'est une avancée majeure pour le développement logiciel.