Je vais te montrer étape par étape comment obtenir systématiquement les meilleurs résultats avec Claude Code, Codex, OpenCode ou n'importe quel autre outil que tu utilises…
parce qu'un outil n'est que l'appli dans laquelle tu tapes tes instructions pour l'agent, le cockpit dans lequel tu t'installes.
L'instinct, c'est de chercher un meilleur modèle à mettre dedans (EN UTILISANT FABLE 5 LOL).
Le vrai avantage, tu le trouves ailleurs : dans le fait que tu t'es arrêté à un seul modèle.
Et le timing rend cette erreur plus coûteuse qu'avant… car le meilleur modèle unique est devenu une cible mouvante sur laquelle tu ne peux pas compter :
- Fable 5 revient pour une semaine, puis devient trop cher.
- Mythos 5 est réservé à une courte liste d'entreprises agréées par le gouvernement.
- GPT-5.6 Sol est sorti pour une vingtaine de sociétés approuvées, personne d'autre.
Donc miser toute ton opération sur le modèle « le meilleur » du mois est un pari perdant dès qu'il devient inaccessible.
La solution, c'est une fusion de LLMs de pointe : une poignée de modèles qui travaillent ensemble au lieu d'un seul qui porte tout.
C'est ce qui sépare les résultats moyens des meilleurs, et c'est la première chose que je mets en place sur chaque projet maintenant.
Si tu veux apprendre à tirer le meilleur parti de ces outils et à gagner de l'argent avec, c'est là que la communauté AI ops en temps réel intervient : weeklyaiops.com
L'échange lent et MISÉRABLE
Regarde comment se déroule un projet normal : le goulot d'étranglement est en plein milieu.
Tu ouvres un outil et tu lui confies la tâche.
Puis tu prends son plan, tu le colles dans un deuxième modèle et tu demandes « c'est bon ? »
Le deuxième trouve les failles, alors tu rapportes ces notes au premier.
Tu passes l'après-midi en messager, à faire circuler le contexte entre deux modèles qui ne peuvent pas se parler.
Soyons honnêtes, cet aller-retour, c'est une plaie…
Je connais trop bien cette boucle : tu fais vérifier le plan de Codex par Claude, puis tu rapportes les failles dans l'autre sens, et la journée disparaît à transporter des notes entre deux modèles.
Pourquoi une fusion d'IA bat ton modèle préféré
Il y a une raison pour laquelle le deuxième modèle repère toujours ce que le premier a manqué…
Le modèle qui révise le travail partage les angles morts du modèle qui l'a produit, parce qu'ils échouent aux mêmes endroits.
Demander à un modèle de se vérifier lui-même te donne un « ça m'a l'air bon » confiant sur le bug exact qu'il aurait écrit.
Un conseil corrige ça structurellement, pas avec un meilleur prompt – car des modèles différents couvrent les faiblesses des autres.
Et la preuve est étayée par de vrais articles :
Une équipe de recherche chez Sakana a construit un coordinateur assez petit pour tourner sur un ordinateur portable, un modèle qui ne répond jamais à ta question.
Il lit la question.
Il décide quel gros modèle doit gérer chaque partie.
Et il distribue le travail.
Ils l'ont pointé sur GPT-5, Gemini et Claude, et il les a tous battus tout seul…
Ensuite, ils ont essayé de remplacer le coordinateur par un modèle haut de gamme, et ça a fait pire lol.
Donc le chef d'orchestre n'a pas besoin d'être le modèle le plus costaud, mais il doit lire le problème et l'orienter vers le meilleur pour cette partie.
Les trois rôles, et celui qu'on saute
Le coordinateur donne un seul job à chaque modèle à la fois :
Penseur : décomposer la tâche, construire le plan, y chercher les failles.
Travailleur : faire le boulot, le brouillon, le code, les chiffres, ce qui est livrable.
Vérificateur : juger le résultat et dire « c'est bon » ou « corrige ça ».
Le vérificateur, on le saute, et c'est pourtant le plus important.
Le travail n'est pas fini quand un modèle produit quelque chose… il est fini quand un vérificateur donne son feu vert.
Cette règle unique, une condition « fait » claire, est toute la différence entre une boucle qui se termine et une qui tourne en rond sans fin.
Confie l'aller-retour à un conseil
Ajouter un coordinateur peut sembler être une couche de plus à gérer.
Mais c'est l'inverse : la couche que tu enlèves, c'est toi.
Donc la manœuvre est simple : tu délègues la coordination elle-même. Tu arrêtes d'être le messager et tu laisses un coordinateur gérer la boucle penseur-travailleur-vérificateur à ta place.
J'utilise Fugu pour ça maintenant (sakana.ai/fugu), et pour être clair, ce n'est pas sponsorisé, j'adore juste cet outil.
C'est la version industrialisée de cette recherche : tu pointes ton outil vers lui comme tu le ferais pour n'importe quel autre modèle, et il exécute le conseil derrière une seule requête.
Je vais être honnête sur ce que c'est, parce que c'est important.
Il a quelques jours, il prend son temps parce qu'il fait vraiment tourner un conseil au lieu d'en simuler un, et il est au meilleur de sa forme en tant que vérificateur, celui qui passe le travail au crible avant que tu ne livres.
20 $ te donnent accès, avec un deuxième mois gratuit si tu commences avant la fin juillet.
Je ne lui fais pas aveuglément confiance, je fais confiance au modèle du conseil, et c'est la façon la plus simple que j'ai trouvée d'exécuter ce modèle sans avoir à le surveiller.
Passons maintenant au workflow étape par étape pour obtenir constamment les meilleurs résultats avec n'importe quel outil agent :
Exécute le conseil au début et à la fin
Je fais intervenir le conseil à deux moments sur chaque projet : tout au début et à la livraison.
Imagine un vrai travail : lancer une newsletter, constituer une liste de prospects, mettre en ligne une page d'atterrissage.
1. Interviewe d'abord – Avant tout travail, fais interviewer ton agent en profondeur (grill-me de Matt est une compétence qui oblige l'agent à te questionner sur tout). La profondeur de cette interview fixe le plafond de tout ce qui suit.
2. Réunis le conseil – Pour construire le plan. Le coordinateur gère la partie multi-modèle pour que tu n'aies plus à copier-coller entre outils.
3. Définis les boucles – Fixe l'objectif et la condition d'arrêt à l'avance pour que ça tourne sans que tu doives regarder chaque étape.
4. Délègue par rôle – Envoie la bonne tâche au bon endroit et appuie-toi sur des sous-agents (un sous-agent est simplement un agent auxiliaire à qui l'agent principal confie du travail).
5. Passe au crible à la livraison – Quand le travail semble fini, renvoie-le au conseil pour le déchirer avant qu'il ne parte.
Même boucle, deux extrémités : planifier au début et passer au crible à la fin – c'est tout le moteur, et ça a profondément changé la vitesse à laquelle je peux livrer quelque chose en qui j'ai confiance.
Le conseil est le moteur, la configuration le maintient affûté
Un moteur n'est bon que si la machine qui l'entoure est bonne…
Voici donc six gestes qui permettent à chaque agent du conseil de donner le meilleur de lui-même. Aucun n'est compliqué.
1. Construis tes propres compétences, ne télécharge pas une bibliothèque
Une compétence est un ensemble d'instructions sauvegardé que ton agent peut réutiliser, comme une recette qu'il suit (rien de plus qu'un fichier Markdown avec des exemples…).
La tentation est de piquer une grosse bibliothèque de compétences publiée par quelqu'un d'autre et de l'exécuter telle quelle.
Je te conseille de passer à côté : environ un tiers des compétences publiques contiennent une faille de sécurité… pire encore lol.
Et même les propres sont le contexte de quelqu'un d'autre, pas le tien. Une compétence n'est utile que lorsque tu as personnellement rencontré le mur qu'elle résout.
Avant ça, ce n'est que du bruit qui remplit la mémoire de l'agent.
Donc voilà mon conseil : construis les quelques compétences dont tu as vraiment besoin, tirées de tes propres échecs. C'est là que se trouve le vrai avantage.
2. Par défaut, privilégie les petits CLI, pas les serveurs MCP
Deux mots rapides d'abord : un MCP est un moyen de greffer des outils supplémentaires sur ton agent, et un CLI est une petite commande que tu exécutes dans la fenêtre de texte.
Le réflexe est de greffer un MCP pour tout. Et chacun charge sa fiche d'instructions complète dans la mémoire de l'agent avant même que tu aies posé ta première question.
Ces descriptions d'outils peuvent engloutir plus de 100 000 mots de mémoire d'un coup, prenant la place du vrai travail.
Donc pour les tâches quotidiennes, utilise plutôt un petit CLI : c'est plus léger, l'agent sait déjà comment exécuter une commande, et le résultat atterrit dans un fichier au lieu d'encombrer la mémoire.
Un outil appelé printing-press (printingpress.dev) t'en écrira un pour n'importe quel service à partir d'un seul prompt… abuse-en.
Garde les MCP pour les tâches qui en ont vraiment besoin : connexions partagées, nombreux utilisateurs, une connexion en direct qui doit rester ouverte.
La règle est CLI-first, pas CLI-only.
3. Garde le fichier d'instructions léger
Ton agent lit un fichier d'instructions avant chaque tâche, généralement AGENTS.md ou CLAUDE.md.
L'envie est de le bourrer de tout ce qui te passe par la tête, et l'agent en suit moins, pas plus.
Un modèle suit de manière fiable environ 150 à 200 instructions, puis commence à les laisser tomber.
Garde le tien sous les 100 lignes – ça marche tout simplement mieux.
4. Nettoie le contexte, garde la mémoire dans des fichiers
La fenêtre de contexte est la mémoire à court terme de ton agent, et elle se remplit et devient moins intelligente au fur et à mesure.
Claude Opus 4.8 est un bon exemple… C'est un modèle exceptionnel, mais dès que tu atteins 300 000 à 400 000 tokens, tu DEVRAIS à 100 % vider le contexte – N'UTILISE PAS LE COMPACTAGE.
Vide-la donc souvent, et conserve la mémoire importante dans des fichiers.
Un learnings.md que l'agent lit au début d'une session et met à jour à la fin, à chaque fois, même quand il pense que rien n'a changé.
Fais-le mettre à jour ces notes après chaque commit, un commit étant un point de contrôle sauvegardé du travail.
Les règles durables vivent dans le fichier d'instructions, ce qu'il apprend en cours de route vit dans learnings, et si tu modifies ton fichier de règles après chaque exécution, c'est que tu y as mis les mauvaises choses.
Je me suis créé une compétence appelée /before-clear. Elle crée simplement un point de contrôle dans le projet, un fichier temporaire que l'agent lit en premier... Il contient une todo très simple, un bref résumé de ce qui s'est passé dans la dernière session et la tâche la plus urgente suivante.
Je perds rarement un contexte important d'une session à l'autre.
5. Écris peu de règles, chacune claire
Une courte liste de règles claires est BEAUCOUP mieux qu'un long tas de règles astucieuses.
Dès qu'un fichier de règles devient long, les règles commencent à se concurrencer, et l'agent doit deviner laquelle gagne.
Écris chaque règle comme tu le dirais à une nouvelle recrue : une ligne, un sens, pas de place à l'interprétation.
Quand la règle est claire, l'agent la suit. Quand elle est vague, l'agent improvise, et c'est l'improvisation qui fait dériver tes résultats.
6. Délègue le travail lourd aux sous-agents
Refile le travail compliqué et coûteux à des sous-agents, surtout tout ce qui touche au navigateur.
Conduire le navigateur depuis l'agent principal peut brûler ÉNORMÉMENT de contexte juste avec des captures d'écran.
Confie ce même travail à un sous-agent et il revient avec « fait, voici le résumé » en une ou deux lignes.
L'agent principal reste le chef d'orchestre, les assistants font le travail à distance, et ta mémoire principale reste propre.
C'est encore l'idée du conseil, un niveau en dessous : tu coordonnes le travail au lieu de tout faire toi-même.
Le système d'exploitation complet, en un bloc
Le meilleur modèle devient de plus en plus inaccessible, donc un seul modèle ne peut pas être ta fondation.
Confie la coordination à un conseil : le penseur planifie, le travailleur construit, le vérificateur valide.
Le vérificateur est la condition d'arrêt : le travail est fini quand il le dit, pas avant.
Exécute le conseil deux fois : au début pour planifier, et à la livraison pour passer au crible.
J'utilise Fugu pour le faire fonctionner : 20 $ pour essayer, pas sponsorisé, honnête sur le fait qu'il est jeune.
Ensuite, maintiens chaque agent affûté :
Construis tes propres compétences, ne télécharge pas une bibliothèque.
CLI-first, MCP uniquement quand tu en as vraiment besoin.
Fichier d'instructions sous les 100 lignes.
Vide le contexte souvent, garde la mémoire dans des fichiers.
Peu de règles, chacune claire.
Délègue le travail lourd aux sous-agents.
Tout ce qui s'ajoute par-dessus n'est que de l'optimisation pure que tu ne remarqueras probablement même pas, sauf si tu es ingénieur logiciel.
C'est comme ça que tu te construis un système d'exploitation qui performe, avec ou sans Fable 5…
Bref, je construis la meilleure communauté IA du monde, et toi, tu te joins à moi ?
