Aller au contenu
Blogue Krizaka

08

Construire presque seul, avec des agents

12–23 oct. 202618 min de lecture

Ce que j'ai affronté, Une trentaine d'agents, une seule nuit; Ce qu'on a construit, des règles écrites après chaque erreur

Une longue table couverte de rangées de petites cartes de papier sous des guirlandes lumineuses, un minuscule oiseau parmi elles, de la neige derrière la fenêtre

Le 12 octobre, mon Mac a saturé. Plusieurs agents de code travaillaient en même temps sur Krizaka, chacun avec ses builds, ses conteneurs et son simulateur, et le système a fini par refuser d'ouvrir un fichier de plus. Je raconte la panne dans le billet sur le Mac. Ce jour-là, j'ai compris une chose simple : laisser des agents écrire du code, ce n'est pas de la magie. C'est de l'organisation.

Ce chapitre raconte comment je suis passé du vibe coding à des règles, comment je range les accès, comment les scripts tiennent l'entreprise, et ce qui s'est cassé une nuit où une trentaine d'agents travaillaient en même temps.

Comment je suis sorti du vibe coding

Le vibe coding, c'est demander à une IA d'écrire du code, regarder si ça a l'air de marcher, et continuer. Au début, c'est grisant. Puis le Mac sature, une session casse ce qu'une autre a fait, et on ne sait plus qui a changé quoi.

Un système devient agentique quand on lui donne cinq choses : un objectif, des outils pour agir sur le monde, de la mémoire pour savoir où il en est, une boucle qui planifie, agit, regarde le résultat et recommence, et une approbation humaine avant tout ce qui a un effet réel.

Schéma de la boucle agentique : un objectif mène à un plan, le plan à un outil (avec approbation humaine), l'outil à une observation qui nourrit le plan, jusqu'à un résultat ; mémoire, budget et journal d'audit encadrent la boucle

La cinquième fait la différence entre un agent et un stagiaire laissé seul avec les clés.

Krizaka est en grande partie écrit par des sessions d'agents que je dirige, souvent plusieurs en parallèle. Ce qui a changé, ce ne sont pas les agents, ce sont les garde-fous autour.

Un fichier de règles que chaque session lit avant de commencer : un test qui échoue d'abord, puis le correctif ; jamais de fusion tant qu'une vérification est rouge ou en attente ; une petite pull request par étape. Un verrou pour les tâches lourdes, ajouté le 12 octobre. Une CI qui refuse ce qui ne passe pas. Et des règles écrites après chaque erreur : une fusion faite trop tôt, avant la fin d'une analyse de sécurité, a donné la règle « jamais de fusion avec un check en attente » ; une session qui a affiché un secret dans sa sortie a donné un garde automatique qui refuse toute commande capable de le faire.

Ce que j'en retiens : un agent ne devient pas fiable parce qu'il est intelligent. Il devient fiable parce qu'on lui donne un objectif clair, des outils limités, des tests qui disent non, et une personne qui approuve ce qui compte.

Les erreurs qui m'ont appris

Quand j'ai commencé Krizaka, je pensais avoir besoin d'un compte GitHub et d'un hébergeur. Cette semaine, j'ai fait le compte. Douze services, et plus de 80 valeurs secrètes : des clés d'API, des tokens, des mots de passe de bases de données. Pour une entreprise où je suis seul, avec des agents d'IA qui écrivent une grande partie du code.

Chaque service répond à un besoin simple : le code et la CI, les paquets publiés, le cloud et les bases, les GPU loués à l'heure, les médias, le courriel, les noms de domaine, la vérification anti-robot des formulaires, et pour le mobile, les outils de construction, les notifications et un compte de développeur. Aucun n'est un luxe. Mais chacun apporte au moins une clé, souvent plusieurs : une par environnement, une par application, une avec moins de droits pour la CI.

Schéma : douze services rangés par rôle autour d'une petite entreprise de logiciels : code et CI, paquets, cloud et bases, GPU, médias, courriel, domaines, anti-robot, applications mobiles ; au centre, plus de 80 secrets gardés hors du code

La règle de base, je l'ai écrite très tôt : un secret n'est jamais dans le code, jamais dans un dépôt, jamais dans une conversation. Même pas dans une conversation avec un agent d'IA, et surtout pas là.

Concrètement, les secrets vivent dans un dossier privé, hors des dépôts, sur ma machine. Les applications déployées les reçoivent comme des secrets de la plateforme qui les héberge, jamais en clair dans un fichier versionné.

Pour lire un secret, il y a un petit script qui va chercher une seule clé à la fois et ne l'affiche jamais : on la met dans une variable, on l'utilise, c'est tout. Et quand je veux vérifier qu'elle est bien là, je regarde sa longueur, pas sa valeur.

Les variables sont nommées par leur rôle, pas par le fournisseur. Changer de fournisseur, c'est alors changer une valeur, pas renommer des variables dans dix dépôts.

Je n'ai pas inventé ces règles par prudence. Je les ai écrites après des erreurs.

Une session d'agent a affiché dans sa sortie l'adresse complète d'une base de données, mot de passe compris. Elle voulait juste vérifier une configuration. Il a fallu changer le mot de passe tout de suite. Depuis, un garde tourne avant chaque commande d'agent : si la commande pourrait afficher un fichier de secrets, elle est refusée, avec un message qui explique comment faire autrement. Même un « masquage » maison est refusé, parce que c'est souvent par là que ça fuit.

Un GPU loué est resté allumé environ deux heures après la fin du travail, pour rien. Son watchdog devait l'éteindre, mais il n'avait pas la clé pour le faire. Je le raconte dans le billet sur les coûts. Depuis, une boucle de surveillance arrête la machine après vingt minutes sans travail.

Un mot de passe est resté à son ancienne valeur quelque part après une rotation. La leçon : une rotation n'est finie que quand chaque endroit qui utilise la clé a la nouvelle, et on vérifie chaque endroit, pas seulement le premier.

Une tâche faite trois fois devient un script

Quand on travaille en TI, la première chose qu'on apprend, c'est qu'une tâche qu'on fait trois fois à la main finit par devenir un script. On le fait pour les déploiements, pour les tests, pour la CI. Ce qui m'a pris plus de temps, c'est de me l'appliquer à moi-même : à la gestion de ma propre entreprise.

Ce chapitre décrit des habitudes, pas le contenu de mon dossier : vous n'y trouverez ni chemin, ni montant, ni nom de compte. C'est volontaire, et c'est un peu le sujet.

Au début, la gestion ressemblait à ce que font beaucoup de gens qui démarrent : une console par fournisseur à ouvrir pour voir ce qu'on consomme, des reçus à classer un par un, et des dates à garder en tête. Quand on a plusieurs services, ça s'accumule.

Je suis passé aux scripts par petites étapes, toujours de la même façon : je fais la tâche une fois à la main, la deuxième fois je note les étapes, la troisième fois j'écris le script.

  1. Je note ce que je fais à la mainUne liste de gestes : ouvrir, copier, classer, vérifier.
  2. Je l'écris en petit scriptUn fichier, une tâche, aucune dépendance si possible.
  3. Je lui donne un nom courtUne commande npm facile à retenir, qui reste la même quand le script change.
  4. Je lui fais vérifier son propre travailUn test, un contrôle, un message clair quand une source est indisponible.
  5. Je laisse GitHub la lancer à ma placeCe qui doit se produire chaque jour ou chaque semaine devient une automatisation planifiée.
  • Où est-ce que je regarde ?

    À la main
    Dans la console de chaque service.
    Avec un script
    Dans une seule commande. Elle les interroge à ma place, en lecture seule.
  • Que se passe-t-il quand une source est en panne ?

    À la main
    Je ne m'en aperçois pas.
    Avec un script
    Le rapport le dit. « Non disponible : raison », jamais un chiffre deviné.
  • Qui se souvient des échéances ?

    À la main
    Ma mémoire.
    Avec un script
    Un calendrier calculé. Il compte les jours et signale ce qui approche.
  • Combien de temps ?

    À la main
    Quelques minutes, chaque fois.
    Avec un script
    Quelques secondes. Et le même résultat à chaque fois.

Tout part d'un seul dossier privé sur ma machine. Il n'est dans aucun dépôt public. Il contient les documents de l'entreprise, un dossier de scripts et un fichier package.json dont les commandes sont mon tableau de bord.

json
{
  "private": true,
  "scripts": {
    "status": "affiche l'état du jour, les décomptes et les alertes",
    "calendar": "calendrier des échéances de l'année",
    "inbox": "classe ce que j'ai déposé dans la boîte d'entrée",
    "backup": "sauvegarde horodatée et chiffrée",
    "verify": "contrôle d'intégrité : doit finir à zéro erreur"
  }
}

Le script que j'utilise le plus est celui de la boîte d'entrée. Je dépose n'importe quel document dans un dossier, et le script s'occupe du reste. Quatre règles, toutes apprises en les oubliant une fois :

  • Le dossier n'a que deux zones : privé et non privé. Je ne trie pas par type de fichier, le script reconnaît lui-même un PDF, une image, un tableau ou un texte.
  • Ce qui est privé est protégé en lecture dès l'arrivée, et les informations sensibles qu'il contient sont masquées dans tout ce que le script affiche.
  • Un document déposé deux fois n'est gardé qu'une fois. Je ne veux pas accumuler de doublons.
  • Les registres restent triés et cohérents, et un script de vérification refuse de se terminer en succès si quelque chose cloche.

La dernière règle compte le plus. Un script de vérification qui finit en erreur, c'est un petit rappel qui me dit de corriger avant de passer à autre chose.

Mon dossier privé répond à « où en est l'entreprise ». GitHub répond à « où en est le travail », et là aussi, tout ce qui peut tourner seul tourne seul. La feuille de route de l'organisation est un projet GitHub. Je ne la mets pas à jour à la main : des automatisations et des agents tiennent le tableau à jour. Chaque pull request écrit Closes suivi du ticket qu'elle règle, et le tableau suit ces Closes #….

  • Un contrôle quotidien vérifie que les sites de la famille restent bien visibles des moteurs de recherche, et ouvre un ticket quand ce n'est plus le cas.
  • Les mises à jour de dépendances arrivent groupées, et celles qui sont mineures se fusionnent d'elles-mêmes quand les vérifications sont vertes. Une version majeure reste une décision.
  • Le changelog du site est lu à partir des versions publiées, jamais écrit à la main.

Une trentaine d'agents en une nuit

Cette nuit, j'ai essayé quelque chose que je repoussais depuis un moment. Au lieu de faire avancer les issues une par une, on en a confié une trentaine à des agents de code sur GitHub : des composants pour Krizaka UI, des animations, des corrections dans le moteur d'Orazaka, des écrans pour Akinaza, une relecture juridique de nos conditions. Chaque agent part d'une issue, ouvre une branche, et revient avec une pull request.

Quelques heures plus tard, j'aurais dû trouver une pile de PR prêtes à relire. J'ai surtout trouvé des choses qui avaient cassé. Pas à cause des agents, pour la plupart. À cause de nous.

Des PR vides

Cinq PR, sur Akinaza et Yomizaka, avaient un titre, une belle description de ce qui avait été fait, et zéro fichier modifié. En lisant le journal d'une session, j'ai trouvé la dernière ligne : le travail était fait, commité, mais le push avait été refusé.

Nos repos lancent une vérification complète avant chaque push. Dans cette vérification, il y avait un test qui allait lire la liste de nos icônes sur notre CDN. L'agent travaille dans un bac à sable qui n'a pas accès à Internet, sauf à quelques adresses. Le test échouait, le push était refusé, et le travail restait dans le bac à sable. Perdu.

La correction a été simple. Le test compare maintenant nos icônes à un fichier de hachages versionné, sans réseau. La comparaison avec le CDN se fait toujours, mais dans la CI, qui a le réseau. On n'a rien affaibli : on a mis chaque vérification là où elle peut tourner.

Une CI qui ne tournait pas

D'autres PR avaient du contenu, des tests, et restaient bloquées. Elles n'étaient pas rouges, elles n'étaient rien : la vérification obligatoire n'avait jamais démarré. Sur GitHub, un push fait par un agent attend qu'un humain approuve le lancement des workflows. Personne ne l'avait fait, et personne ne le voyait.

En attendant le bon réglage, notre propre app GitHub pousse un commit vide sur la branche, et la CI démarre. Ce n'est pas élégant, mais c'est écrit, et tout le monde sait pourquoi.

Du Java qui ne compilait pas

La PR qui m'a le plus appris venait du moteur. Un agent avait optimisé le chemin critique de la saga d'Orazaka : moins de requêtes par étape, un cache des définitions de Studios. Sur le papier, c'était bien pensé. Sauf que le code ne compilait pas, et que le formatage n'avait jamais été appliqué.

L'agent n'avait pas mal travaillé. Il n'avait simplement jamais pu construire le projet. Un composant d'Orazaka ne se construit pas seul : son POM parent et ses modules en amont viennent du workspace complet, et l'agent n'avait que le repo du composant. Il l'a dit lui-même dans sa PR, en une ligne. Il a quand même poussé.

On a écrit une action qui monte le workspace avant que l'agent commence : elle clone les repos, installe les modules en amont, relie les packs à côté de sa copie. Chaque repo Java l'appelle. Un agent qui ne peut pas construire ne peut pas vérifier, et un agent qui ne peut pas vérifier ne devrait pas pousser.

Un prompt qui inventait

Pour la relecture juridique, j'ai demandé à Orazaka, notre propre moteur, d'écrire le prompt de l'agent. Le plan était bon. Mais il citait deux repos qui n'existent pas, des liens gouvernementaux qui n'existent pas, et une règle d'annulation de 14 jours qu'il attribuait à la loi québécoise sur la protection du consommateur. Elle n'en vient pas.

On a corrigé avant de publier l'issue, et on a laissé la sortie brute en commentaire, pour qu'on puisse comparer. C'est exactement le genre d'erreur qu'un document juridique ne peut pas se permettre. Et une consigne ne règle pas le fond : un modèle qui ne peut rien vérifier ne sait pas qu'il se trompe. Le vrai remède, c'est que le moteur aille lire les sources lui-même, et les cite. C'est le prochain chantier d'Orazaka.

  1. PushCinq PR videsUn test avant le push lisait notre CDN depuis un bac à sable sans réseau. Désormais : un fichier versionné d'empreintes ; la comparaison au CDN se fait en CI.
  2. CIUne vérification jamais lancéeUn push fait par un agent attend qu'un humain approuve les workflows. Désormais : notre application pousse un commit vide.
  3. BuildDu Java qui ne compilait pasL'agent n'avait que le composant, pas l'espace de travail. Désormais : une action le prépare avant qu'il commence.
  4. PromptUn prompt qui inventaitDeux dépôts, des liens et une règle de 14 jours qui n'existent pas. Désormais : corrigé avant publication ; le moteur devra citer ses sources.
Quatre façons dont la nuit a cassé, et ce que chacune a changé. Rarement la faute des agents : la nôtre.

Les règles qu'on a écrites

Tout ça tient maintenant dans une section de notre charte d'ingénierie, celle que chaque repo de l'organisation hérite. Construire avant de pousser, et si on ne peut pas, le dire et s'arrêter. Commenter son avancement sur l'issue, parce que c'est là que je suis le travail. Des tests qui n'ont pas besoin du réseau. Ne rien inventer. Ne jamais affaiblir un garde-fou pour passer au vert, même quand ce garde-fou vit dans un autre repo. Et laisser l'administrateur régler chaque paramètre, au lieu de l'écrire en dur.

Aucune de ces règles n'est nouvelle pour un humain. Ce qui change avec un agent, c'est qu'il arrive sans contexte. Ce qu'on ne lui écrit pas, il ne le sait pas.

Une dernière chose est sortie de cette nuit. En voulant corriger quelques noms de repos, je me suis rendu compte qu'un nom de repo est écrit à des dizaines d'endroits : dans les pipelines de CI, dans le manifeste du workspace, dans les déploiements, dans les données du site. Renommer un repo, aujourd'hui, c'est une chasse au trésor.

Alors on prépare une sorte de build pack pour la CI. Ce n'est pas encore livré. Voici la forme visée : chaque repo n'aurait plus qu'une ligne.

yaml
# Forme visée, pas encore livrée : ce fichier n'existe pas.
jobs:
  ci:
    uses: krizaka/.github/.github/workflows/krizaka-ci.yml@v2
    secrets: inherit

Le reste serait décidé par des workflows réutilisables de krizaka/.github, un par type de projet : node-ci.yml, java-ci.yml, python-ci.yml et expo-ci.yml, en version 1.x. Ils regarderaient ce qu'il y a dans le repo et lanceraient la bonne chaîne. Le build pack qui les réunirait reste à faire. Un registre unique des repos remplacerait les noms écrits à la main, et un script listerait tout ce qui cite un repo avant de le renommer.

Ce chantier-là, c'est un agent qui le fait en ce moment, avec le rôle de DevOps, dans un périmètre limité et sans rien déployer. Je relirai sa PR comme les autres.

Le jour où on a voulu finir

Le 23 octobre, je voulais tout finir. Pas un petit lot de tickets : les issues ouvertes depuis des semaines, les écrans d'Akinaza, les modules de Krizaka TypeScript, la frise du blog, l'app Mac de Yomizaka, les premières tranches d'Orazaka. Je me disais qu'avec des agents de code qui travaillaient en parallèle, et moi qui relisais, la journée suffirait.

Ça n'a pas été le cas. Mais j'ai appris des choses que je veux écrire, parce qu'elles serviront la prochaine fois.

Le matin, ça avançait partout. Des tickets se fermaient, des pull requests se fusionnaient. Au total, plus de cent soixante PR ont été fusionnées dans la journée, sur trente-trois dépôts. Mais chaque avancée ouvrait une autre chose à surveiller. Un agent de code prenait des issues et ouvrait des PR, des sessions d'agents travaillaient sur d'autres branches. Chacune avait son contexte et ses limites, et pour que le travail avance, il fallait savoir où en était chacune. En fin d'après-midi, j'avais moins l'impression d'avancer que de gérer un chantier : tout bouge, et il faut décider quoi regarder en premier.

Les quotas se sont épuisés deux fois. Le quota de l'agent de relecture a cédé en premier : depuis le matin, chaque tâche échouait au premier tour, avec un message de limite d'usage. Il s'est épuisé une seconde fois en milieu de journée, juste après une tâche. Les sessions d'agents ont aussi atteint leur limite hebdomadaire, et plusieurs se sont arrêtées. Quarante-huit PR vides ont été fermées, chacune avec une explication. Leurs issues sont restées ouvertes, en file d'attente. Les sessions ont sauvegardé leur travail, et elles reprendront par un message.

Il y a eu aussi la CI. Un push fait par un agent ne lance pas les workflows tant qu'un humain ne les a pas approuvés. Une PR peut donc avoir l'air prête, avec du code et des tests, sans qu'aucune vérification ne tourne. Ça ne se voit pas tout de suite, et on passe vite.

Ensuite, il y a eu la relecture. L'agent de relecture regardait chaque PR, l'agent corrigeait, la relecture repartait, et on repartait pour un tour. Chaque tour consommait du quota, celui-là même dont on avait besoin pour le travail. J'ai arrêté de relancer la relecture à chaque correction : une seule relecture par PR, à son ouverture, et je règle moi-même les petites remarques plutôt que de renvoyer l'agent faire un tour de plus.

En début d'après-midi, c'est la machine qui a dit stop. Sept sessions tournaient en même temps, avec l'agent de relecture, et des builds étaient lancés en parallèle, en dehors du verrou qu'on utilise pour n'en lancer qu'un à la fois. La charge a atteint 133 sur 10 cœurs. À ce niveau, tout ralentit, et les builds se gênent entre eux. Les agents ne sont pas une capacité en plus. Ils se partagent la même machine.

La charge de la machine au plus fort, face à ses cœurs : sept sessions et des builds hors du verrou, sur 10 cœurs.

Charge moyenne lue sur la machine le 23 octobre ; une charge au-dessus du nombre de cœurs, c'est du travail qui attend son tour.

Graphique en barres, 2 (Cœurs de la machine – Charge au plus fort). 23 octobre, début d'après-midi : de 10 à 133, en hausse de 1 230 %.

La charge de la machine au plus fort, face à ses cœurs : sept sessions et des builds hors du verrou, sur 10 cœurs. — données
Élément23 octobre, début d'après-midi
Cœurs de la machine10
Charge au plus fort133
La charge de la machine au plus fort, face à ses cœurs : sept sessions et des builds hors du verrou, sur 10 cœurs.

J'ai pris quelques décisions, et elles tiennent en peu de mots. Trois sessions actives au plus, et une seule tâche lourde à la fois. On finit avant de commencer : une étude ne démarre pas avant que la précédente soit validée, et chaque ADR est validé avant toute ligne de code. Les chantiers qui ne sont pas dans les priorités passent en pause, et reprennent un par un, dès qu'une session active se termine, depuis leur dernier état.

Finir avant de commencer. Une PR ouverte, une issue en cours, une session lancée prennent chacune quelque chose : du quota, de l'attention, de la place sur la machine. Tant que rien n'est fusionné, ce n'est pas fini. C'est une dette qui attend.

Une tâche lourde à la fois. Trois builds en parallèle ne vont pas plus vite qu'un seul. Ils se gênent, et tout le monde perd du temps.

Le modèle le moins cher qui suffit. Une correction de texte ou un test simple n'a pas besoin du modèle le plus puissant. Je garde les gros modèles pour les décisions d'architecture, et je regarde ce que coûte chaque session.

La relecture automatique, sur chaque PR. Elle a trouvé de vrais bugs avant qu'ils n'arrivent sur la branche principale. Elle consomme du quota, donc il faut la surveiller pour qu'elle ne tourne pas en boucle, mais je la garde.

Un humain décide et fusionne. Les agents ouvrent les branches, poussent le code, répondent aux commentaires. Ce qui entre dans la branche principale, c'est moi qui le décide, et c'est moi qui fusionne. Ce n'est pas de la méfiance envers eux. C'est le seul moyen de savoir ce qui a été vérifié, et par qui.

On n'a pas tout fini ce jour-là. Il reste des PR en attente, des issues en file, et des décisions qui reviennent à moi. Mais la règle est écrite, et c'est elle qu'on suit maintenant.

Chapitre 08

Résultats

commandes npm dans le dossier privé de gestion

27

Une tâche faite trois fois devient un script

valeurs secrètes, lues une à la fois

80

Les erreurs qui m'ont appris