Le vrai goulot d’étranglement n’est plus le code, mais sa relecture

L'entrée de Meta sur le marché du codage par IA cette semaine s'est accompagnée d'une affirmation précise qui mérite qu'on s'y attarde. Muse Code, le nouvel agent de codage de l'entreprise fonctionnant dans un terminal, ne se contente pas d'écrire du code fichier par fichier — selon le message de lancement de Mark Zuckerberg, lorsqu'une tâche est suffisamment importante, il « se répartit entre des sous-agents distincts travaillant en parallèle dans des worktrees isolés » et, d'après les propres tests de Meta, il aurait construit simultanément six fonctionnalités pour un jeu sans aucune collision. Il s'agit d'une affirmation du fournisseur concernant son propre produit le jour de son lancement, et non d'un résultat vérifié indépendamment ; il faut donc considérer ce nombre précis avec scepticisme. Mais la structure du flux de travail décrite n'est pas une idée propre à Meta — l'exécution parallèle et isolée par des agents devient un modèle par défaut dans tout le domaine des agents de codage, et cela change ce que signifie réellement « être bon dans ce domaine ».

Ces deux dernières années, l'argument de vente des outils de codage par IA portait essentiellement sur la vitesse dans un seul fil : un agent, une tâche, un diff à examiner. C'est une compétence que la plupart des ingénieurs ont déjà à moitié assimilée — lire le diff, lancer les tests, livrer. Répartir le travail entre plusieurs agents travaillant dans des worktrees isolés rompt avec ce modèle. Vous n'examinez plus une modification cohérente issue d'un seul fil de pensée. Vous examinez plusieurs modifications simultanées, raisonnées indépendamment, qui doivent toutes converger vers un système fonctionnel sans se contredire, dupliquer la logique ou être silencieusement en désaccord sur le comportement d'un élément partagé de la base de code.

Pourquoi il s'agit d'une compétence réellement différente, et non d'une version plus rapide de l'ancienne

Examiner un diff écrit par une IA consiste principalement à vérifier sa justesse : fait-il bien ce qu'il prétend faire, casse-t-il quelque chose à proximité ? Examiner plusieurs résultats d'agents parallèles ajoute une dimension que la plupart des gens n'ont jamais eu à exercer, car jusqu'à récemment aucune fonction individuelle ne l'exigeait : la cohérence entre les diffs. Deux agents ont-ils chacun inventé leur propre version de la même fonction utilitaire ? La modification « isolée » d'un agent dépendait-elle discrètement d'un fichier qu'un autre agent était en train de réécrire ? L'étape de fusion a-t-elle réellement détecté un conflit, ou a-t-elle silencieusement retenu l'hypothèse d'une branche au détriment de celle de l'autre ? Ce ne sont pas des bugs au sens traditionnel — chaque diff individuel peut réussir ses propres tests tout en produisant, une fois combiné, un système incohérent.

C'est le même problème que les équipes d'ingénierie distribuées ont toujours dû gérer avec des contributeurs humains, simplement comprimé en quelques minutes au lieu de quelques jours. La différence, c'est qu'une équipe d'ingénieurs débutants demande naturellement des conseils lorsqu'une tâche semble ambiguë ; un agent optimisé pour terminer la portion qui lui a été attribuée produira souvent une réponse assurée et syntaxiquement propre à la mauvaise question. Pour le détecter, il faut quelqu'un qui ait suffisamment compris la tâche pour la décomposer dès le départ — ce qui signifie que la véritable compétence limitante n'est pas de « réviser du code rapidement », mais de « découper un travail en éléments pouvant être exécutés en parallèle en toute sécurité, et savoir lesquels ne le peuvent pas ».

Le schéma plus général, au-delà des seuls outils de codage

Il vaut la peine de remarquer que cela ne se limite pas aux outils destinés aux développeurs. La refonte par Google de sa boîte de recherche — dévoilée la même semaine — intègre AI Overviews et AI Mode dans un même flux capable de prendre comme entrées du texte, des images, des PDF, des vidéos et des onglets Chrome ouverts, et confie le travail à un agent plutôt qu'à un analyseur de requêtes. Le point commun entre ces deux lancements est le même : l'interface s'éloigne de « donner à l'IA une instruction claire et vérifier un résultat clair » pour aller vers « confier à l'IA un objectif défini de manière vague et un ensemble d'entrées, puis la laisser déterminer les étapes ». Ce schéma apparaît partout où des outils agentiques sont déployés, et pas seulement dans les éditeurs de code — ce qui signifie que la compétence consistant à examiner et à orchestrer sera pertinente bien au-delà des métiers de l'ingénierie, pour toute personne dont le travail consiste à diriger un système d'IA dans une tâche en plusieurs étapes plutôt qu'à lui donner une seule invite.

Ce qu'il faut réellement pratiquer, concrètement

Si vous écrivez ou gérez du code, quelques habitudes précises et vérifiables permettent de développer ce savoir-faire plus rapidement que la simple lecture de textes à ce sujet :

• Apprenez ce qu'est réellement un worktree isolé (la fonctionnalité de git qui permet d'extraire simultanément plusieurs branches dans des répertoires distincts) avant de croire l'affirmation d'un outil selon laquelle les modifications parallèles « ne peuvent pas entrer en collision ».worktreeL'isolation pendant l'exécution ne garantit pas la cohérence au moment de la fusion — il s'agit d'une étape distincte qu'il vaut la peine de surveiller attentivement.
• Donnez délibérément à un agent de codage une tâche suffisamment importante pour qu'il doive la décomposer, puis lisez la manière dont il répartit le travail avant de lire les diffs qui en résultent. La décomposition vous en dit davantage sur la possibilité de faire confiance au résultat que le code lui-même.
• Entraînez-vous à examiner les diffs par lots, et non un par un. La capacité à garder simultanément à l'esprit trois ou quatre modifications liées et à repérer leurs désaccords est différente du fait d'examiner chacune isolément et de l'approuver selon ses seuls mérites.
• Demandez ce qui se passe en cas de conflit, et pas seulement en cas de succès. Tout outil qui prétend effectuer automatiquement des fusions parallèles devrait pouvoir vous montrer ce qu'il fait lorsque deux agents touchent réellement à la même logique — ce chemin d'échec, davantage que le chemin nominal, vous indique si l'outil est suffisamment sûr pour lui confier du travail réel.

Rien de tout cela ne nécessite d'attendre que votre employeur adopte un produit précis. Le schéma — décomposer, distribuer, reconverger, vérifier — apparaît désormais chez des agents de codage de plusieurs fournisseurs ainsi que dans les interfaces d'IA grand public. Les personnes qui se familiarisent avec la gestion de ce cycle, plutôt que de se contenter d'examiner des résultats à un seul fil, développent une compétence qui reste pertinente quelle que soit l'entreprise dont l'agent finira par s'imposer.