Cet article est un retour d'expérience. Il ne cherche pas à établir une méthode universelle, mais à documenter un déclic dans ma manière de travailler avec les agents IA.
Depuis plusieurs mois, j'utilise quotidiennement des agents IA pour développer mes projets.
Ces derniers mois, j'ai vu arriver les MCP (protocole connectant un agent à des outils/données externes), les skills, les loops, les agents autonomes, les plugins tiers...
Je les ai intégrés progressivement à ma façon de travailler.
Et pourtant, il y a quelques jours, j'ai eu un déclic.
Pas parce qu'une nouvelle fonctionnalité est sortie.
Pas parce qu'un nouveau modèle est arrivé.
Simplement parce que j'ai commencé à assembler ces briques différemment.
Des outils... chacun dans son rôle
Au départ, chaque outil avait sa place.
GitHub Projects me servait à suivre l'avancement du projet.
Les Issues représentaient les tâches.
Avec le temps, je me suis également rendu compte que, dans mon expérience, les échanges de conception étaient souvent plus fluides sur les plateformes Web, tandis que les agents CLI excellaient dans l'exécution.
Avec le recul, je crois surtout que les outils sont arrivés à un niveau de maturité qui m'a permis de les utiliser autrement.
Je passais naturellement de l'un à l'autre.
Mais, dans mon esprit, ils restaient des outils indépendants.
Le déclic
Puis, en travaillant sur un nouveau projet, j'ai voulu expérimenter une autre façon de procéder.
Plutôt que de passer directement à l'exécution, j'ai utilisé la plateforme Web (via son connecteur GitHub) pour réfléchir au projet et générer les premières Issues.
Ces Issues alimentaient ensuite le Project, pendant que les agents prenaient le relais sur l'implémentation.
C'est à ce moment-là que quelque chose a changé.
Je me suis aperçu que je passais davantage de temps à regarder le Project qu'à attendre le résultat final.
Je suivais le cheminement du projet.
Et surtout, je pouvais intervenir avant qu'il ne s'engage trop loin dans une direction qui ne me convenait plus.
C'est notamment arrivé lorsque l'agent s'apprêtait à développer une interface d'administration.
En regardant le Project, je me suis arrêté.
Pourquoi construire cette interface ?
Quelques minutes plus tard, la réponse m'est apparue comme une évidence.
Elle était destinée... à moi.
Pour piloter le projet.
Mais avais-je encore besoin de cette interface ?
En y réfléchissant, je me suis rendu compte que je préférais collaborer directement avec l'agent via un MCP plutôt que de développer une interface uniquement pensée pour administrer le projet.
L'idée n'était pas mauvaise.
Elle ne correspondait simplement plus à ma façon de travailler.
Un espace de travail partagé
C'est à ce moment-là que la lumière s'est allumée.
Je n'étais plus simplement en train de discuter avec un LLM (le modèle de langage derrière l'agent).
Je n'étais plus non plus en train de déléguer du développement à un agent.
J'avais le sentiment que nous évoluions dans le même espace de travail.
Les conversations servaient à réfléchir.
Les Issues formalisaient les décisions.
Le Project donnait une vision d'ensemble.
Les agents exécutaient.
Et moi, je pouvais observer, arbitrer, réorienter.
Je ne découvrais plus le résultat une fois terminé.
Ce que ce déclic a changé
Je ne sais pas si cette façon de travailler est nouvelle.
Elle ne l'est probablement pas.
D'autres ont certainement eu ce déclic avant moi.
Mais je réalise que, jusqu'à présent, je regardais surtout les outils.
Aujourd'hui, je commence à regarder la manière dont ils s'articulent entre eux.
Et ce n'est pas la même chose.
Le connecteur GitHub a été l'élément déclencheur de cette réflexion.
Mais, avec le recul, je ne pense pas que GitHub soit le véritable sujet.
Demain, ce pourrait être GitLab, Gitea ou toute autre plateforme capable d'offrir le même niveau d'intégration.
Ce que je retiens, c'est moins l'outil que la méthode.
Je n'interagis plus avec les agents de la même manière.
J'ai désormais le sentiment qu'ils travaillent dans le même environnement que moi.
Cette nuance peut sembler minime.
Pour moi, elle change profondément la manière dont je conçois un logiciel.
Je ne présente pas cette réflexion comme une vérité.
C'est simplement le récit d'un déclic.
Le moment où j'ai compris que les outils n'avaient pas changé.
C'était ma manière de les assembler qui venait d'évoluer.
Et je pense que je ne regarderai plus ces outils de la même façon.
Pour moi, ce déclic est récent. Et j'ai le sentiment qu'il ne s'agit que du début.