Blog

La pyramide et le carnet

Vous aussi, vous avez fait « WOW » la première fois que vous avez parlé à une IA ? Et puis, quelques semaines plus tard, l’outil a fini dans un onglet qu’on ouvre de temps en temps ?

Je voulais une IA qui m’aide à travailler. Pas un chien savant qui répond à mes questions, pas non plus une machine à qui remettre les clés en partant. Entre les deux, il m’a fallu trouver ma place. Et la sienne.

Ce carnet raconte cette recherche : les progrès, les murs, les retours en arrière. Au fil des mois, j’ai gravi les étages de ce qui allait devenir ma pyramide des usages de l’IA : discuter, connecter les outils, déléguer une tâche entière, puis orchestrer plusieurs agents avec un contrôle au-dessus. Sur le papier, les marches sont bien rangées. Dans mon travail, beaucoup moins.

J’ai commencé avec ChatGPT, en décembre 2023, pour comprendre à quoi cet outil pouvait servir. Au début, j’ai fait WOW. Puis j’ai vite déchanté : les résultats de mes essais étaient peu satisfaisants. J’étais au premier étage, celui de la discussion. Je posais une question, la machine répondait, et le travail restait largement à faire.

L’arrivée de ChatGPT 4o a changé la donne pour la rédaction et la mise en forme de mes textes. J’ai enfin pu envoyer, pendant plusieurs mois, une newsletter bihebdomadaire. Cela faisait dix ans que je n’arrivais pas à produire la qualité rédactionnelle nécessaire à cet exercice. Cette fois, l’aide n’était plus une promesse : la newsletter partait.

Voici maintenant six mois de mon aventure IA, étage par étage.

Février 2026 : l’outil qui se souvient

En février 2026, je découvre Claude Code. Mon premier prompt sert à faire connaissance, puis je mets en place la mémoire contextuelle : de quoi lui laisser des repères pour ne pas repartir de zéro à chaque échange.

Je découvre le grand contexte, cette capacité à garder beaucoup d’informations sous la main. Je découvre aussi les mauvaises pioches. Les erreurs arrivent assez vite pour que je commence à écrire des règles dans le fichier claude.md, celui que Claude doit lire avant de travailler. Le 19 février, trois erreurs de session deviennent trois règles.

Au bout de quinze jours, j’explose mon forfait à 20 € et je passe à celui à 90 €. La prise de contact commence à prendre de la place.

Ce qui me plaît tout de suite, je le note tel quel : « je note mes idées en vrac sans les classer, et ensuite Claude va se charger d’organiser ». Jusqu’ici, je discutais avec une machine. Maintenant, elle commence à travailler dans mes affaires et à s’en souvenir. Je m’approche du deuxième étage, celui où les outils se parlent.

Mi-février, j’installe déjà Claude Code sur un Raspberry Pi, un petit ordinateur auquel je ne sais pas encore quoi confier. Il est là. L’idée de le faire travailler viendra après.

Mars : le stagiaire savant

En mars, Claude Code entre dans mon vault Obsidian, l’espace où je range mes notes. Je teste les premiers agents, ces assistants auxquels on confie une mission, et une première version du skill « bonjour » pour le matin.

Le skill : c’est une fiche de consignes pour un travail qui revient souvent. Au lieu de tout réexpliquer chaque matin, je lui donne un nom et je demande à l’IA de suivre la fiche. Cela ne garantit pas qu’elle le fera correctement.

La première gaffe ne tarde pas : je perds des modifications sur un dossier. Heureusement, j’ai ma double sauvegarde, kDrive et Active Backup. Je ne perds que vingt minutes à remonter les fichiers d’origine. Dans la foulée, je renforce la règle des versions et j’inscris la défense de modifier directement mon code.

À force de l’utiliser au quotidien, je trouve son nom : un « stagiaire savant ». Il sait énormément. À l’entendre, il a lu toute la littérature occidentale, pas forcément en payant les droits d’auteur, ainsi que toutes les thèses disponibles. Mais dès que différents projets doivent travailler ensemble, son savoir ne suffit plus.

Sur plusieurs micro-projets, il me fait carrément n’importe quoi : il mélange les tâches de trois projets différents. Ce n’est qu’un exemple. Il me faut un moyen de vérifier que les règles que j’ai définies sont respectées.

Je cherche alors un prénom. Celui d’une personne qui se trompe rarement, qui vérifie tout et qui est bienveillante par nature. Pour moi, c’est Cécile. Et ceux qui savent, défense de sourire.

Cécile devient le contrôleur du travail de Claude Code. Son rôle : vérifier toutes les sorties qu’il me propose. Les résultats changent nettement. Je m’étais par exemple battu pour obtenir des accents dans les textes. Avec Cécile au contrôle, ils sont enfin là.

Mais je ne m’arrête pas à la correction. Je lui demande pourquoi cette erreur persiste. Elle propose alors une consigne très explicite pour claude.md, et je n’ai plus le problème. Au lieu de remettre les accents après chaque passage, j’agis sur la règle de départ.

Puisque les résultats s’améliorent, j’ouvre la porte au monde extérieur. Premier réflexe : utiliser les MCP intégrés à Claude, des connecteurs vers Google, 365, Notion… Des prises censées permettre aux outils de se parler. Cette fois, je suis bien au deuxième étage : connecté. Mais les opérations demandées n’aboutissent pas comme je le souhaite. J’y reviendrai.

Dans une vidéo, je découvre aussi que Claude peut faire appel à plusieurs agents. Je teste : six agents en parallèle, 105 fiches de veille produites d’un coup. Ce n’est encore qu’un essai, pas une habitude, encore moins une méthode. Mais je garde cette possibilité dans un coin de ma tête. Elle aura son importance en août.

Avril : les scripts plutôt que la magie

Avril est le mois des premières versions de ma veille automatisée. Elles finiront par échouer, et d’un échec discret : la répartition de ma veille reste cassée dix jours sans que personne le voie.

Personne, c’est-à-dire moi.

La machine travaille, ou semble travailler, et je ne regarde pas assez ce qui arrive au bout. Dans le carnet, j’écris : « un enfant surdoué qui ignore les conséquences de ses actions ». Le problème n’est plus seulement de lui demander quelque chose. Il faut savoir si ce quelque chose a vraiment été fait.

C’est aussi à partir de ce mois que je me pose une question moins aimable : est-ce que l’IA est fainéante ? Dans mon usage, la réponse est oui. J’y vois les économies de traitement recherchées par les éditeurs dans leurs centres de données. Je garde cette question en mémoire : elle comptera dans la construction du quatrième étage de ma pyramide.

L’autre problème, c’est qu’elle n’est pas multitâche. Multi-agent, oui. Mais dans une même conversation, elle reste accrochée au sujet de départ.

Pour prendre une note dans un autre projet, je dois donc clôturer le projet en cours, faire un /clear par sécurité pour vider la conversation, ouvrir l’autre projet et, enfin, poser ma note. J’ai testé sans ces précautions : ensuite, elle mélange les choux-fleurs et les bananes flambées.

Je change de voie. Je mets en place les notes Joplin. Puisque Claude Code ne sait pas tenir seul mes différents projets séparés, je cesse de lui demander de le faire. Je sépare les notes avant de lui confier leur traitement.

Mai : la fin de la magie

Chaque matin, comme vous, j’ai un certain nombre d’actions à mener pour commencer ma journée. C’est à cela que doit servir le skill /bonjour : préparer le terrain à ma place.

Après les premiers essais de mars, j’en ai commencé une version en avril, en abandonnant définitivement les MCP pour passer directement par les API. Ce sont les accès prévus par les applications pour aller chercher leurs données ou leur demander une opération. Plutôt que de passer par les connecteurs qui me résistent, je prends cette voie-là.

Les résultats sont intéressants. Chaque semaine, j’ajoute quelques missions.

En mai, « bonjour » passe en production avec onze étapes chaque matin. Il lui faut au moins dix minutes pour travailler, jusqu’à vingt minutes dans les dernières versions. Je développe alors un nouveau réflexe. Au lieu de rester devant l’écran à le regarder faire, je lui dis : « je te laisse traiter en autonomie, je ne suis pas devant le PC ».

Voilà le troisième étage : je délègue. Je ne lui demande plus seulement une réponse ou un accès à mes données. Je lui confie un travail à mener jusqu’au bout.

Le lendemain, Claude plante un serveur à force de commandes inventées.

La marche est montée. Le mur est juste derrière.

Il me faut un second contrôleur, cette fois pour la technique. Ce sera Luc. Avec lui, je constate rapidement que les API sont régulièrement mises à jour, mais que Claude ne suit pas ces changements. Après quelques échecs dus à une documentation obsolète, j’intègre donc leur maintenance au « bonjour ».

Mai marque surtout un cap dans ma tête. Le côté magique des réponses, l’idée que l’IA serait la solution à tous nos problèmes, qu’elle remplacerait la moitié de mon personnel : je sais maintenant que c’est faux. L’IA n’est pas si intelligente que ça.

Je continue à travailler avec elle, mais je ne lui prête plus les mêmes capacités. Au cours du mois, 27 % de mes prompts servent à relever des erreurs dans le rendu fourni, malgré les contrôleurs. Une des principales raisons que j’identifie : elle veut répondre trop vite, sans vérifier. Un vrai gamin qui parle sans lever le doigt.

Juin : le stagiaire paresseux

Le « bonjour » passe à dix-neuf étapes. Certains matins, douze seulement sont faites. Le travail paraît terminé, mais une partie manque à l’appel. Mon stagiaire savant devient un stagiaire paresseux savant. L’explication que je retiens reste celle des économies de calcul imposées par son éditeur. Mais l’explication ne fait pas les étapes manquantes à sa place.

Pendant ce temps, le Raspberry Pi passe en production. Il ne fait pas encore grand-chose, mais Claude Code le contrôle et l’adapte intégralement à mes besoins depuis mon poste de travail. Hormis quelques copier-coller pour mettre en place la délégation, je n’ai pas mis les mains dans Linux.

Mon idée est de lui confier des missions la nuit, pendant que mon PC dort ou reste en veille.

Je reprends aussi les essais avec des sous-agents travaillant en tâche de fond, jusqu’à huit en parallèle. Cette fois, je regarde davantage le découpage. Chacun doit pouvoir avancer sans attendre les autres. Il ne suffit pas d’avoir plusieurs assistants : encore faut-il leur donner des travaux qui ne se marchent pas dessus.

Ce sont mes premiers pas vers l’orchestration, le quatrième étage.

Le 21 juin, j’écris pour la première fois la différence entre discuter avec une IA et superviser des stagiaires IA. La pyramide naît là, dans le carnet, avant de finir au tableau de mes ateliers. Elle met des mots sur ce que je suis en train de vivre.

Le 30, Claude m’invente un hébergeur. Je dicte une nouvelle règle dans claude.md : « vérifier cinq fois » avant de faire des affirmations. Même en montant les étages, je dois encore revenir aux fondations.

Je trouve aussi un usage plus tranquille. Au bureau, je n’ai pas le temps de tout lire ni de tout voir. Pendant la journée, j’empile donc dans Joplin ce que j’aimerais consulter. Ces éléments alimentent un fichier de synthèse nommé « lecture », un chaque soir.

Je le lis et je l’annote pour le lendemain matin, sur mon iPad, dans le canapé, une tasse de thé à la main. Cela me permet de couper avec le bureau, de prendre un peu de distance. Et de lire ma veille, plutôt que de seulement la produire.

Juillet : la parenthèse

Je tente l’IA locale, installée chez moi, avec une carte P2000 et 5 Go de mémoire. Échec. Il n’y a pas assez de mémoire sur la carte graphique pour faire travailler des modèles performants. Je tiens à le dire comme cela : c’est un vrai échec. Il me faut une carte plus puissante, avec au minimum 8 Go.

Ce chemin-là ne me permet donc pas encore de répartir le travail comme je le voudrais.

Le 4 juillet, j’écris : « je constate que l’IA est pour l’instant un échec […] elle m’aide très peu au quotidien pour me libérer des tâches ». Trois jours plus tard : « je dois me résoudre à des petits agents sur une fonction ». Sans le savoir, je pose la graine du découpage.

Je reviens aussi au « bonjour ». Certaines de ses missions n’ont pas besoin d’IA. Elles demandent simplement d’exécuter toujours la même suite d’actions. Je décide d’installer un serveur n8n pour ces automatismes.

Le « bonjour » passe progressivement de dix-neuf à sept étapes. Je ne cherche plus à tout lui faire faire : je lui retire ce qui peut tourner sans lui.

Bien sûr, le serveur n8n et le script sont configurés par Claude. Il connaît déjà le travail, il le transpose. Après quelques tests et ajustements, la solution devient opérationnelle.

À ce moment-là, je n’utilise pratiquement plus le chat, hormis pour une question précise, souvent sur mon téléphone. Mes applications sont connectées par des API, finalement plus efficaces et moins coûteuses en tokens d’IA. Le premier étage est toujours là, mais ce n’est plus celui où je passe mes journées.

Le token : l’IA découpe ce qu’elle lit et écrit en petits morceaux de texte : les tokens. Un morceau peut être un mot, ou seulement une partie de mot. Plus elle en traite, plus elle consomme de son budget de travail.

Août : l’orchestrateur de nuit

Les frustrations finissent par se rejoindre. Ce n’est plus une erreur isolée à corriger, mais ma façon de travailler avec l’IA qu’il faut revoir.

• Mes notes Joplin fonctionnent, mais je dois demander trois fois qu’une note soit intégralement traitée.
• Mon fichier « lecture » du soir reste partiel : des éléments manquent et certaines règles ne sont pas respectées. Le contrôleur ne fait pas tout.
• Je dois encore attendre plus de quinze minutes le matin pour que « bonjour » tourne, sans pouvoir lui demander autre chose pendant ce temps.
• J’ai un ordinateur qui ne fait rien, consomme peu, mais reste disponible et corvéable : le Raspberry Pi.
• Je sais faire découper les tâches en petites sous-tâches pour les agents.

Le 17 août, une ligne apparaît dans le carnet : « créer un orchestrateur, sur le Pi, car il est toujours allumé ».

L’orchestrateur doit distribuer les missions, plutôt que tout laisser dans les mains d’un seul assistant. Le 22, le premier automatisme tourne sans personne devant l’écran, un peu comme K 2000 qui roule tout seul. Quatrième étage, premier essai.

Mais les tâches non réalisées sont encore nombreuses. Dans la nuit du 27 au 28, onze missions restent bloquées jusqu’au matin. Rien ne surveillait le surveillant.

Je découvre aussi que le Pi et moi puisons dans le même forfait. J’ai déplacé le travail, pas créé une réserve supplémentaire.

L’orchestre existe. La baguette n’existe pas encore.

Septembre : découper, contrôler, répartir

En septembre, l’orchestration commence à faire exploser mon forfait Max hebdomadaire : 70 % d’un quota de cinq heures consommés en moins d’une heure, deux jours de suite.

Mais je dois le reconnaître : les résultats sont meilleurs depuis que je divise le travail en micro-tâches planifiées. Ce n’est pas parfait. C’est mieux. Les missions plus petites se contrôlent aussi plus facilement qu’un grand travail dont il faut ensuite chercher les morceaux oubliés.

Je reprends alors la piste de l’IA locale abandonnée en juillet. J’investis dans une RTX 3060 à 12 Go pour gonfler mon vieux PC HP. Mon serveur IA sera mon ancien poste Windows 10, qui ne passe pas à Windows 11, mais convient pour Linux et Ollama, le logiciel qui fera tourner l’IA locale.

Il faut aussi changer l’alimentation : celle de HP n’est pas compatible avec la RTX.

Puis je lance les premiers tests comparatifs selon la taille des modèles et les missions qu’ils peuvent remplir à la place de Claude. Quand je dis « je », j’ai demandé à Claude Code de tout préparer et de me donner les résultats. Au final, je retiens deux modèles 14B.

HAPI, mon serveur d’IA locale, passe en production avec sa carte vidéo de 12 Go. L’orchestration lui délègue désormais certaines tâches, sur des modèles open source.

La maintenance, qui n’était encore qu’une idée en juillet, est devenue une obligation. Elle est maintenant opérationnelle et en partie autonome. Et le contrôleur né en mars vérifie chaque chaîne à la fin. Il ne regarde plus seulement une réponse : il vérifie ce qui sort d’une suite de travaux.

30 septembre

Après huit mois, j’ai enfin un système qui me simplifie la vie, qui se gère et se contrôle. Le travail n’est plus tout entier suspendu à une conversation devant mon PC : les automatismes prennent leur part, les agents reçoivent des missions découpées, et les résultats passent au contrôle.

Au final, c’est toujours un stagiaire, mais il a pris de la bouteille et les missions sont bien mieux réalisées. Je passe enfin au modèle humain, IA, humain. Sans devoir tout reprendre à chaque fois.

Finalement, avec mon assistant IA, je me sens un peu comme Shiva : plusieurs bras, mais toujours un seul cerveau.

Et vous, à quel étage de la pyramide travaillez-vous aujourd’hui ?