Un modèle par rôle, au niveau d'intelligence suffisant
Développer à partir de spécifications avec moins d'humain dans la boucle : chaque étape devient un rôle, servi par l'intelligence minimale qui suffit. Le développeur devient product owner et fixe tôt qui valide quoi.
- Catégorie
- Note
- Publié
- Temps de lecture
- 5 min de lecture
- Sujets
- Ingénierie logicielle
- Étiquettes
- #agents#llm#models#governance#specs
La concurrence entre freelances et les attentes des clients poussent à produire plus. Le freelance n'a pas à se plier à l'IA : il peut la faire converger vers ses pratiques et ses savoirs. Pour réduire la part de l'humain dans la boucle, il faut donc d'abord recopier les étapes du développement continu : spécifier, découper, coder, tester, relire, décider, maintenir. Ce qui change, c'est qui tient chaque étape.
Si les agents sont les développeurs, le cadre naturel est le développement piloté par les spécifications. On discute longuement des spécifications, on y ajoute le contexte du métier, des partenariats et des méthodes, puis on en tire les user stories, les tâches et les tests. Le développeur ne tape plus chaque ligne, mais repère les exigences floues et les cas oubliés : il devient product owner, avec un bagage d'ingénieur. Cette posture d'orchestrateur garde ce qui rend le métier plaisant : comprendre le problème, décider, construire.
Addy Osmani résume la répartition : les agents peuvent tenir la boucle interne, celle où l'on enquête, code, teste et rend compte, mais les humains gardent la boucle externe, celle des décisions et de la responsabilité. Un seul modèle cher pour tout coûte trop ; un seul modèle bon marché rate ce qui demande de la réflexion.
Chaque rôle reçoit le modèle le moins coûteux qui fait correctement le travail.
Chaque étape devient un rôleLien vers cette section
La boucle parcourt les tâches une à une, en parallélise certaines, et attend quand il le faut. Claude Code enchaîne déjà une bonne partie de ce travail dans une même session ; séparer les rôles relève du harness, sujet du billet suivant.
Trois catégories de modèles, et un modèle de décisionLien vers cette section
Je raisonne en trois catégories, valables chez n'importe quel fournisseur, ou en les mélangeant : les modèles de pointe, les modèles de second rang, et les modèles plus légers. Chez Anthropic, ce sont aujourd'hui Fable, Opus et Sonnet ; les noms changeront, pas la logique.
Les rôles qui demandent de la réflexion, comme écrire les spécifications ou relire le code, gagnent à utiliser un modèle de pointe, avec un niveau de réflexion élevé plutôt que maximal. Le code peut revenir à un modèle de second rang, moins cher. Pour des tâches petites et bien définies, un modèle plus léger suffit.
Les décisions n'ont pas besoin de texte. Choisir la suite, juger un risque, accepter ou refuser : un modèle de décision comme Jev, de TypeSafe, renvoie directement un choix typé avec un score de confiance, sans passer par un LLM qui génère du JSON. Une IA généraliste coordonne les agents, sous supervision humaine.
La conformité réduit parfois le choix : si le client impose un service attesté, comme dans le billet sur la vérification, il reste surtout des modèles ouverts.
Une boucle longue, qui tourne sans le développeurLien vers cette section
Une boucle d'agents prend du temps. Le développeur la consulte sans attendre qu'un modèle lent termine sa réponse, et l'expérience de développement doit suivre ce rythme.
Avec mon abonnement, j'utilise les sessions cloud de Claude Code, et d'autres fournisseurs proposent l'équivalent. Claude clone le dépôt dans sa propre VM, s'approprie le code, contribue et commite. Sur le code d'un client, cette VM chez le fournisseur demande le même accord du client que tout LLM. Je la suis et la réoriente depuis l'application mobile.
Ces agents ont besoin du savoir utile et de l'historique des sessions, sans rien de local : l'ordinateur doit pouvoir s'éteindre. Plutôt que de leur confier mes propres identifiants pendant que je dors, un gestionnaire de secrets leur délivre, pour chaque tâche, des accès de courte durée limités aux données utiles.
Depuis mon poste, je pilote ces agents à travers un agent principal : coûts, autorisations, identifiants partagés. Donner à chaque agent son propre compte, un portefeuille programmable avec des plafonds de dépense ou une identité décentralisée, permet de régler finement ses permissions et son budget.
Qui décide de quoiLien vers cette section
Le niveau de validation dépend de la gravité d'un problème potentiel et de l'effet du changement.
Ces classes se définissent tôt : on identifie les endroits où une vérification est nécessaire, on fixe leur niveau avec le client, puis on le fait respecter par le code, avec des autorisations, des identifiants et des droits de fusion. Une règle qui n'existe que dans un document repose sur la bonne volonté de chacun.
Osmani propose un « contrat de responsabilité » par base de code : les vérifications convenues pour un changement, les preuves qui fondent la décision, et la personne qui en répond. C'est ce que le client doit pouvoir relire. Les classes répondent aussi à ce qu'il appelle la taxe d'orchestration : l'attention humaine ne grandit pas au rythme des agents. Plus elles sont précises, moins le développeur relit ce qui ne le demande pas, et moins il accumule de dette cognitive.
Des classes de changements dans le dépôtLien vers cette section
Sans flotte d'agents, je commence par lister les types de changements du projet et, pour chacun, qui valide : l'agent seul, moi, ou le client. Un fichier CODEOWNERS les inscrit dans le dépôt :
# .github/CODEOWNERS
* @moi
/infra/ @client/ops
/src/paiement/ @client/tech-leads
Une branche protégée qui exige la revue des code owners le fait respecter. C'est une solution basique : elle ne règle que la revue du code, fichier par fichier. Un vrai projet demande en général un système d'autorisations plus complet, sur les données elles-mêmes : qui, humain ou agent, peut lire ou modifier quoi, et avec quelle validation, comme dans le billet sur le contexte.
Prochain billet : le harness, et pourquoi il vaut mieux ne pas en faire trop.