← Ressources
Tuto · Mode d'emploi · 11 min de lecture

Tes petits tickets traînent : confie-les à un agent de code et relis sa pull request

31 mai 2026

Oui, tu peux confier à un agent de code les petites tâches de dev que tu repousses. Il travaille dans un environnement isolé, lance les tests et te rend une pull request que tu relis avant de merger. Ça marche pour des tâches répétitives et vérifiables par des tests, pas pour les décisions d'architecture.

Exemple fictif, que je garde d'un bout à l'autre : un freelance dev maintient les sites de huit clients, ou une petite agence web ceux de ses clients. Chacun a sa liste de petites tâches : une dépendance à mettre à jour, un README qui ne dit plus la vérité, un test devenu obsolète, un log manquant. Chaque tâche prend une vingtaine de minutes (un ordre de grandeur, pas une mesure). Aucune n'est urgente, aucune n'est facturée, et elles passent toujours après la mission en cours. Au bout d'un trimestre, ce retard ralentit les vraies missions sans qu'on sache dire quand il s'est formé.

En bref

Pour qui
Freelances dev et petites agences web qui ont plus de petits tickets que de temps
Il te faut
Un dépôt GitHub avec une CI verte, et Codex cloud ou Open SWE
Temps
Quelques heures pour un premier essai (mon estimation)
Coût
Codex cloud : voir les offres ChatGPT sur la page officielle. Open SWE : à déployer toi-même, avec le coût du modèle et du sandbox
Niveau
Intermédiaire
Mis à jour le
1 novembre 2026

Le principe : tu décris la tâche, l'agent lit le code, écrit la modification, lance les tests et ouvre une pull request. Tu valides ou tu corriges. Ce tuto couvre les tâches à déléguer, la consigne, les garde-fous et un premier essai cette semaine.

Comprendre ce qu'est un agent de code en arrière-plan

Un agent de code en arrière-plan n'est pas un assistant qui complète ton code pendant que tu tapes. Il prend une consigne, part travailler seul dans un environnement isolé, et revient avec un résultat sous forme de pull request.

Deux produits illustrent la catégorie.

Codex cloud d'OpenAI. Tu décris une tâche depuis ChatGPT (web, mobile ou application de bureau), dans un environnement cloud qui contient tes dépôts et tes outils. Chaque tâche a son propre espace de travail et peut continuer à tourner pendant que ton ordinateur est en veille. Tu relis les changements et les résultats des tests, puis tu fais un commit ou tu ouvres une pull request quand tu es prêt.

Open SWE de LangChain. C'est un agent open source qui enquête sur un dépôt, implémente des changements dans un sandbox isolé, les valide et livre une pull request. Il se pilote depuis un tableau de bord, des issues et conversations GitHub, ou Slack, et sait relire des pull requests. Son README prévient qu'il est en développement actif, avec des changements qui cassent et des garanties de stabilité absentes. Pour le déployer toi-même, il demande un runtime d'agents géré : compte plutôt un chantier qu'un essai d'un après-midi.

Le point commun : travail asynchrone, isolé, qui débouche sur une pull request. Tu ne regardes pas l'agent travailler. Tu lui donnes un objectif, tu fais autre chose, tu relis son travail à la fin. C'est le modèle d'un junior à qui tu délègues une tâche cadrée : tu ne lui tiens pas la main, tu relis sa PR.

Dessin au trait : une consigne de trois lignes, une flèche vers un enclos fermé où un robot code devant un terminal, une flèche vers une feuille de pull request avec deux branches qui se rejoignent.
Tu donnes une consigne, l'agent travaille seul dans son environnement isolé et te rend une pull request.

Choisir les bonnes tâches à déléguer

Délègue ce qui est répétitif, bien cadré et vérifiable par des tests. Garde pour toi ce qui demande du jugement métier, un arbitrage produit ou un contexte que l'agent n'a pas.

NiveauExemples de tâchesRisqueCondition
1Documentation à partir du code, logs, formatage de fichiers ciblés, renommage cohérent dans le dépôtSans risqueAucune
2Mise à jour mineure de dépendances, migration d'un pattern déprécié, cas de test manquants sur une fonction existanteFaibleUne suite de tests solide
3Petite fonctionnalité bien spécifiée, bug reproductible avec un test qui échoueModéréRelecture humaine non négociable

À l'agence fictive, les mises à jour de dépendances de huit sites clients forment une bonne série de niveau 2 : même geste, tests à lancer, résultat vérifiable. Le renommage d'une variable dans quatorze fichiers est de niveau 1.

Ce que tu ne délègues pas : les décisions d'architecture, les changements qui touchent à la sécurité ou aux paiements, tout compromis métier qui n'est pas écrit dans le code. L'agent ne sait pas pourquoi ce hack moche existe depuis deux ans. Toi, si.

Critère pratique : si tu ne peux pas écrire la consigne en trois phrases avec un moyen de vérifier le résultat, la tâche n'est pas prête. Reformule-la, ou garde-la.

Cadrer l'agent : la consigne qui décide de tout

Un agent est littéral : il fait ce que tu écris, pas ce que tu penses. Une consigne floue donne une PR floue, et tu perds plus de temps à relire un travail bancal qu'à faire la tâche toi-même.

Une bonne consigne contient quatre éléments :

  • L'objectif précis. Pas « améliore les tests », mais une fonction, un fichier et des cas nommés.
  • Le périmètre. Ce que l'agent a le droit de toucher, et ce qu'il laisse. Sans périmètre, un agent zélé refactore trois modules voisins pendant qu'il y est.
  • Le critère de réussite. Une commande qui dit si c'est fini et correct. C'est ce qui distingue une délégation propre d'un pari.
  • Les contraintes. Style de code, format de commit, fichiers à ne jamais modifier.

Consigne type, à adapter à ta tâche :

Prompt
Objectif : [ce que tu veux, avec la fonction ou le fichier et les cas à couvrir, par exemple des tests pour `parse_invoice` dans `billing/parser.py` : facture valide, montant négatif, devise manquante].
Périmètre : [les fichiers que l'agent peut modifier, par exemple seulement `tests/billing/`]. Ne touche à aucun autre fichier.
Critère de réussite : [la commande qui doit passer, par exemple `pytest tests/billing/`] et [le seuil à atteindre, si tu en as un].
Contraintes : [style de code, format de commit, fichiers à ne jamais modifier].

Plus la tâche est risquée, plus la consigne doit être serrée. Pour une mise à jour de doc, deux phrases suffisent. Pour une migration de pattern, écris-la comme un ticket pour un dev junior que tu ne pourras pas interrompre pendant qu'il travaille.

Les garde-fous : review humaine et environnement isolé

Un agent sans garde-fou, c'est un stagiaire avec accès à la prod et personne pour relire.

Garde-fou numéro un : l'isolation, et ses limites. Les deux produits font tourner l'agent dans un environnement séparé de ta machine, donc une commande destructrice ne touche pas ton poste. Ne contourne jamais cette isolation en lançant un agent directement sur ton poste avec un accès complet. Mais l'isolation protège ta machine, pas tes dépôts : le README d'Open SWE précise que ses sandboxes peuvent avoir un accès réseau et reçoivent normalement un accès GitHub étendu à l'installation. Limite les dépôts auxquels l'agent a accès, avec des identifiants au strict minimum.

Garde-fou numéro deux : la pull request obligatoire. Active la protection de la branche principale dans GitHub, avec une revue obligatoire avant le merge : l'agent ne peut alors pas y pousser sans passer par une PR relue. La PR passe par ta CI (tests, lint, build) comme celle d'un humain, et un humain la relit. C'est valable même pour une tâche de niveau 1. Une doc fausse générée par un agent et mergée sans relecture reste une doc fausse signée par toi, ou par ton agence.

Garde-fou numéro trois : le périmètre des permissions. Pour Codex, les réglages de l'environnement cloud permettent de limiter l'accès internet. Coupe ce qui n'est pas nécessaire : un agent qui n'a pas besoin d'internet pour sa tâche ne devrait pas en avoir. N'expose au sandbox que les secrets indispensables.

Dessin au trait : un robot enfermé dans un enclos à bordure hachurée, une pull request avec trois coches bleues, une grande loupe à côté.
Trois garde-fous : l'isolation, la pull request obligatoire, et une relecture humaine avant le merge.

Mise en place concrète : ton premier agent cette semaine

Voici comment lancer une vraie délégation sur une vraie tâche.

Étape 1 : choisis une tâche de niveau 1. Prends la plus inoffensive de ta liste, par exemple un README qui ne reflète plus la structure du projet. Tu veux que le premier essai réussisse pour te donner confiance, pas pour prouver que l'agent sait tout faire.

Étape 2 : prépare le dépôt. Vérifie que tes tests tournent et passent en local. Un agent travaille bien sur un dépôt à la CI verte et aux tests qui veulent dire quelque chose. Si ta suite est rouge ou inexistante, commence par là : l'agent en a besoin pour savoir s'il a réussi.

Étape 3 : connecte l'agent à GitHub. Pour Codex cloud, tu crées depuis ChatGPT un environnement avec tes dépôts GitHub, tu le publies, puis tu lances une tâche. Pour Open SWE, suis le guide d'installation du dépôt. Commence sur un dépôt non critique, un projet interne ou un dépôt de test, le temps de calibrer.

Étape 4 : écris la consigne avec les quatre éléments de la section 3. Relis-la comme si tu la donnais à quelqu'un que tu ne peux pas joindre pendant l'exécution.

Étape 5 : lance, puis surveille le début. Si ton outil affiche un plan avant d'exécuter, relis-le : c'est ton meilleur moment pour corriger le tir. Sinon, attends la PR.

Étape 6 : relis la PR comme celle d'un humain. Tests verts en CI, diff lu en entier, périmètre respecté. Si tout est bon, tu merges. Sinon, tu envoies un retour à l'agent ou tu reprends à la main. Codex accepte aussi @codex review en commentaire de PR pour une première relecture automatique : elle ne remplace pas la tienne.

Étape 7 : note ce qui a marché. Garde les consignes qui ont donné une bonne PR comme modèles, et note ce qui a dérapé. Quand une catégorie de tâches tourne bien, tu peux en confier toute la série : c'est là que le gain devient régulier.

L'erreur de mise en place la plus courante : commencer par une tâche complexe pour « vraiment tester » l'agent. Tu testes alors deux inconnues à la fois, la difficulté de la tâche et la fiabilité de l'outil. Premier essai trivial, deuxième un peu plus dur, et ta confiance repose sur des résultats.

Checklist finale

0 sur 6

Et maintenant ?

Un agent de code ne remplace ni ton jugement ni celui de ton équipe. Il retire les corvées répétitives qui mangent du temps, pour que tu le gardes pour l'architecture, les arbitrages et la relation client. L'agent fait le travail ingrat, tu relis, tu valides et tu gardes la responsabilité de ce qui part en prod.

La bonne question n'est donc pas de savoir si les agents de code marchent. Codex cloud et Open SWE existent et ouvrent des pull requests vérifiables. Elle est de savoir par où commencer avec ton stack, ta CI et tes contraintes de sécurité, sans déléguer la mauvaise tâche au mauvais moment. Pour estimer ce que ça te coûte en modèle, regarde comment maîtriser le coût des tokens Claude. Pour garder la tête froide sur le gain réel, lis le paradoxe de la productivité IA.

La suite logique, c'est un mini-outil pour ta boîte en une après-midi : même principe, jusqu'où on peut aller sans se piéger. Je publie ce genre de mode d'emploi dans ma newsletter, tu peux t'inscrire juste en dessous.

Reçois les nouveautés IA

En t'inscrivant, tu reçois le guide « Les automatisations IA utiles en 2027 », puis au plus un mail par semaine avec mes nouveaux articles et tutos.

Au plus un mail par semaine, et le guide offert. Tu te désinscris en un clic, le guide reste à toi. Confidentialité

Articles liés