
Développeur à l'ère des agents IA : qu'est-ce qu'on devient ?
Il y a deux ans, la question était « est-ce que l'IA écrit du bon code ? ». Aujourd'hui, la question a changé : les agents de code lisent un dépôt, modifient plusieurs fichiers, lancent les tests et ouvrent une pull request. Sur beaucoup de tâches, taper le code n'est plus l'étape qui prend le plus de temps.
Alors, qu'est-ce qu'on devient, nous, développeurs ? Mon constat après de nombreux mois à travailler ainsi au quotidien, et à encadrer une équipe qui le fait aussi : le métier ne disparaît pas, il remonte d'un niveau.
Ce qui change vraiment
Le code devient bon marché à produire. Ce qui reste cher, c'est savoir quel code produire, et savoir s'il est correct. Le temps de travail se déplace donc de l'écriture vers ce qui l'entoure : comprendre le besoin, découper, décider, vérifier.
Les quatre casquettes du développeur augmenté
1. Celui qui spécifie
Un agent exécute très bien une intention claire, et très mal une intention floue. Rédiger un bon ticket, avec le contexte, les contraintes et des critères d'acceptation vérifiables, devient une compétence technique à part entière. La spec n'est plus un document pour le chef de projet : c'est l'entrée du programme.
2. Celui qui conçoit
L'agent choisira volontiers la solution la plus probable, pas la plus adaptée à votre système. Les frontières entre modules, le modèle de données, la stratégie de cache, ce qui doit être synchrone ou non : ces décisions restent humaines, et leurs erreurs coûtent plus cher que jamais, car le code qui les implémente se multiplie plus vite.
3. Celui qui orchestre et relit
On passe d'un rôle d'auteur à un rôle d'éditeur : lancer plusieurs tâches en parallèle, relire les diffs, refuser, recadrer, fusionner. La relecture devient l'activité centrale. Une PR de 400 lignes générée en deux minutes demande toujours une vraie lecture, et c'est là que se joue la qualité (voir mes garde-fous pour coder avec un assistant IA).
4. Celui qui répond du résultat
Quand un incident arrive en production, « c'est l'IA qui l'a écrit » n'est pas une réponse. Tests, observabilité, sécurité, performance : le développeur reste responsable de ce qui est fusionné, qu'il l'ait tapé ou non.
Ce qui prend de la valeur… et ce qui se banalise
- Se banalise : le boilerplate, le CRUD standard, la traduction d'une spec claire en code, la recherche de syntaxe, les migrations mécaniques.
- Prend de la valeur : la connaissance du métier et des utilisateurs, la vision système, la capacité à dire non, la sécurité, la lecture critique de code, la communication avec le produit et le design.
- Devient indispensable : savoir écrire des tests qui prouvent quelque chose, et outiller sa CI pour qu'elle attrape ce qu'un humain fatigué laisserait passer.
Le tech lead : cadrer les humains et les agents
Pour un tech lead, le travail s'étend : il faut maintenant rendre le dépôt lisible pour les agents autant que pour les nouveaux arrivants.
- Un fichier d'instructions versionné : conventions, commandes, architecture, interdits. C'est l'onboarding de l'agent.
- Une CI stricte : types, lint, tests, analyse de sécurité. C'est le garde-fou qui ne se fatigue pas.
- Des PR petites et lisibles : la règle vaut doublement quand le code est généré.
- Des règles claires : quels outils sont autorisés, quelles données ne doivent jamais sortir, qui valide quoi.
# AGENTS.md (extrait)
- Stack : Next.js App Router, TypeScript strict, Prisma
- Avant de terminer : pnpm lint && pnpm test
- Ne jamais modifier les migrations déjà appliquées
- Toute nouvelle route API valide ses entrées avec zod
- En cas de doute sur un choix d'architecture : proposer, ne pas déciderEt les juniors ?
C'est la vraie question difficile. Les tâches simples qui servaient d'apprentissage sont justement celles que l'IA absorbe en premier. Le risque : des développeurs qui savent faire générer du code, mais pas le comprendre ni le déboguer.
Ma position : l'IA peut accélérer l'apprentissage si on l'utilise pour comprendre, pas pour sauter l'étape. Faire expliquer un code inconnu, demander pourquoi une approche est meilleure, écrire soi-même puis comparer. Et côté équipe, continuer à confier de vraies responsabilités aux juniors, avec du pair programming et des code reviews pédagogiques.
Comment s'y préparer, concrètement
- Renforcer les fondamentaux : HTTP, bases de données, concurrence, sécurité. On ne peut pas relire ce qu'on ne comprend pas.
- S'entraîner à écrire : specs, critères d'acceptation, ADR. Écrire clairement, c'est désormais programmer.
- Pratiquer la relecture : lire du code, beaucoup, et savoir expliquer pourquoi on le refuse.
- Se rapprocher du produit : comprendre pourquoi on construit, pas seulement comment.
- Tester les outils, garder son esprit critique : ils évoluent tous les mois, le jugement reste.
Conclusion
On écrit moins de code à la main, mais on porte plus de responsabilités. Le développeur devient à la fois spécificateur, architecte, éditeur et garant de la qualité. Ce n'est pas la fin du métier : c'est la fin d'une partie du métier, la plus mécanique. Ce qui reste, comprendre un problème et construire la bonne solution, a toujours été le cœur du travail.