TL;DR

• L'IA pour coder a evolue en 3 phases : autocomplete, chat dans l'IDE, agent autonome. Chaque phase est un changement de paradigme.
• Mon workflow quotidien repose sur Claude Code comme binome : il planifie, implemente, teste. Je supervise, valide, oriente.
• L'IA excelle sur le boilerplate, les tests, les migrations et le refactoring multi-fichiers. Elle echoue sur l'architecture et la logique metier.
• Le gain reel est de 2-3x sur les bonnes taches, 0.5x sur les mauvaises. Pas de "10x developer" — c'est du marketing.
• La regle d'or : ne jamais merger sans relire. L'IA est un excellent junior, pas un architecte.

De Copilot a Claude Code : un an de transformation

En 2024, j'ai ignore Copilot. Ca completait des lignes, ca tombait juste une fois sur deux, et ca me deconcentrait plus qu'autre chose. En 2025, j'ai teste Cursor. La, quelque chose a change : discuter avec un modele qui voyait mon code, c'etait autre chose. En 2026, Claude Code est devenu mon binome de dev. Voici ce que j'ai appris en un an d'utilisation quotidienne.

Ce n'est pas un article sponsorise. C'est un retour d'experience honnete, avec ce qui marche et ce qui ne marche pas. Si tu cherches du "l'IA va remplacer les devs", passe ton chemin.

L'evolution en 3 phases

L'IA pour coder a suivi trois etapes distinctes. Et chacune est un saut qualitatif, pas une simple amelioration.

Phase 1 : Autocomplete (2022-2024). Copilot, TabNine. Le modele complete la ligne en cours. C'est glorifie par le marketing, mais en pratique c'est un IntelliSense sous steroides. Utile pour le boilerplate, frustrant des que le contexte depasse quelques lignes.

Phase 2 : Chat dans l'IDE (2024-2025). Cursor, Continue, Cody. Tu peux parler a ton code. Le modele voit tes fichiers, comprend le contexte, peut editer plusieurs endroits. C'est le moment ou j'ai commence a changer mes habitudes. Au lieu de chercher sur Stack Overflow, je demandais au chat. Au lieu d'ecrire un test a la main, je le decrivais.

Phase 3 : Agent autonome (2025-2026). Claude Code, Devin, les background agents de Cursor. L'agent ne se contente pas de repondre : il planifie, execute, teste, et corrige en boucle. Tu lui donnes un objectif, pas une instruction ligne par ligne. C'est un changement fondamental dans la relation dev-outil.

La difference entre ces phases n'est pas juste technique — c'est une difference de posture. En phase 1, tu codes et l'IA aide. En phase 2, tu collabores avec l'IA. En phase 3, tu supervises l'IA.

Mon workflow quotidien

Concretement, voici a quoi ressemble une journee type.

Le matin : review des agents

Claude Code propose des background agents qui tournent en autonomie. Le matin, je review ce qu'ils ont produit pendant la nuit ou la veille. C'est comme reviewer le travail d'un collegue : je lis le diff, je verifie la logique, je teste. Parfois c'est impeccable. Parfois c'est a cote de la plaque. Exactement comme avec un humain.

Feature development : decrire, valider, superviser

Mon process pour une nouvelle feature :

1. Decrire l'objectif en langage naturel. Pas du pseudo-code, un vrai brief : "Ajoute un composant de partage social sur les articles du blog. Boutons Twitter, LinkedIn, copier le lien. Style coherent avec le reste du site."
2. Laisser l'agent planifier. Claude Code analyse le code existant, propose un plan d'implementation. C'est la que je valide ou corrige.
3. Lancer l'implementation. L'agent cree les fichiers, ecrit le code, integre dans les pages existantes.
4. Review le code. Ligne par ligne. C'est non-negociable.
5. Tester. Build, dev server, tests manuels sur le navigateur.

Ca ressemble beaucoup a une code review avec un junior. La difference : le junior ne se vexe pas quand tu rejettes sa PR, et il produit un premier jet en 3 minutes au lieu de 3 heures.

Bug fixing : l'IA dans son element

C'est probablement la ou l'IA m'a le plus impressionne. Tu colles l'erreur, le stack trace, et l'agent part lire le code, identifier la cause, et proposer un fix. La chaine de raisonnement est visible : il lit le fichier concerne, remonte les imports, verifie les types, et propose une correction.

Sur un bug que j'aurais mis 30 minutes a tracer dans une pile de middlewares, l'agent trouve la cause en 2 minutes. Pas toujours. Mais souvent.

Refactoring multi-fichiers

L'autre force de l'agent : appliquer un pattern de refactoring sur 15 fichiers. Renommer une abstraction, migrer une API, uniformiser un style. Tu decris le pattern, il l'applique partout. Ce qui aurait pris une apres-midi de find-and-replace prudent se fait en quelques minutes.

Quand l'IA excelle

Les taches ou l'IA apporte le plus de valeur ont deux caracteristiques : repetition elevee et complexite moderee.

• Boilerplate : composants UI, routes API, schemas de validation. L'IA genere du code structurellement correct en quelques secondes.
• Tests unitaires : decrire le comportement attendu, l'IA ecrit les cas de test. C'est repetitif, ca suit des patterns — parfait pour un modele.
• Migrations : de React class components a hooks, de CommonJS a ESM, d'une version de framework a une autre. L'agent connait les patterns de migration.
• Documentation : generer la JSDoc, les README, les commentaires d'API. L'IA est infatigable sur les taches que personne ne veut faire.
• Exploration de codebases inconnues : "Explique-moi comment marche l'authentification dans ce projet." L'agent lit le code et synthetise. C'est plus rapide que de tracer soi-meme.

Les taches repetitives et les taches d'exploration — c'est la que l'IA brille.

Quand l'IA echoue

Et puis il y a les moments ou l'IA fait perdre du temps.

Decisions d'architecture. L'IA suit les patterns qu'elle connait. Elle ne va pas inventer une architecture adaptee a ton contexte specifique. Si tu lui demandes "comment structurer ce service ?", elle va te proposer le pattern le plus courant — pas forcement le plus adapte. L'architecture demande de la compehension du domaine, des contraintes business, de la vision long terme. L'IA n'a rien de tout ca.

Logique metier complexe. Un calcul de tarification avec 15 regles de gestion, des cas limites lies a la reglementation, des exceptions historiques — l'IA va generer quelque chose qui compile mais qui est faux sur les cas limites. Elle n'a pas le contexte metier pour distinguer les regles critiques des regles secondaires.

Securite. L'IA peut introduire des vulnerabilites. Elle va generer du code qui marche mais qui n'echappe pas correctement les inputs, qui ne valide pas les permissions, qui expose des donnees sensibles. Ne jamais faire confiance a l'IA sur la securite sans review humaine.

L'IA est un excellent junior. Pas un architecte.

Les patterns qui marchent

Apres un an d'utilisation, voici les pratiques qui font la difference entre "l'IA me fait gagner du temps" et "l'IA me fait perdre du temps".

Donner du contexte : CLAUDE.md

Le fichier CLAUDE.md a la racine du projet est le game changer le plus sous-estime. C'est un fichier qui decrit ton projet a l'agent : stack technique, conventions, structure des dossiers, commandes de build. Claude Code le lit automatiquement. Sans ce fichier, l'agent devine. Avec, il comprend.

J'y mets : la stack, les alias de paths, les conventions de nommage, les commandes de validation, les comportements specifiques du projet. C'est 30 minutes d'investissement qui evitent des heures de corrections.

Plan avant code

Ne laisse jamais l'agent coder sans avoir valide le plan. Quand tu decris une feature, demande d'abord "propose un plan d'implementation". Lis le plan. Corrige-le si necessaire. Ensuite seulement, lance l'implementation.

C'est du prompt engineering applique au workflow : structurer l'interaction pour obtenir de meilleurs resultats.

Petits commits, review incrementale

Avec un agent qui produit du code vite, la tentation est de le laisser generer 500 lignes d'un coup. Mauvaise idee. Mieux vaut des commits petits et frequents, chacun reviewe individuellement. Ca permet de detecter les derives tot et de corriger le cap.

Tests d'abord

Mon pattern prefere : faire ecrire les tests par l'agent avant l'implementation. Tu decris le comportement attendu, l'agent ecrit les tests, tu valides les tests, puis l'agent implemente pour les faire passer. C'est du TDD assiste par IA, et ca marche remarquablement bien.

Ne jamais merger sans relire

C'est la regle d'or. Peu importe la qualite apparente du code genere, je relis tout avant de merger. L'IA produit du code qui a l'air correct. Qui compile. Qui passe les tests. Mais qui peut contenir des subtilites incorrectes, des cas limites oublies, des choix d'implementation discutables.

La review humaine n'est pas optionnelle. C'est le filet de securite.

Le cout reel

Soyons honnetes sur les chiffres.

Sur les taches ou l'IA excelle (boilerplate, tests, refactoring), le gain est de l'ordre de 2-3x. Une tache de 2 heures se fait en 45 minutes. C'est significatif, mais ce n'est pas le "10x developer" que vend le marketing.

Sur les taches ou l'IA est mal adaptee (architecture, logique metier complexe), le ratio tombe a 0.5x. Tu passes plus de temps a corriger et rediriger l'agent qu'a faire toi-meme. Et le code produit est souvent de moindre qualite que ce que tu aurais ecrit.

En moyenne sur une journee complete, je dirais 1.5-2x de productivite en plus. C'est bien. C'est pas une revolution. C'est un outil puissant utilise correctement.

Le vrai gain n'est pas la vitesse. C'est l'energie mentale. Les taches repetitives et ennuyeuses sont deleguees. Je garde ma concentration pour les decisions d'architecture, les reviews, la logique metier. Ca change la qualite du travail, pas juste la quantite.

Ce qui va changer

L'evolution est rapide. Voici ce que je vois arriver :

Des agents plus autonomes. Les background agents actuels sont limites. Dans 6 mois, ils gereront des workflows complets : lire un ticket Jira, implementer, tester, ouvrir la PR. L'humain interviendra de moins en moins dans l'execution, de plus en plus dans la supervision.

Le protocole MCP partout. MCP standardise la connexion entre agents et outils. Aujourd'hui, ton agent peut lire ton code et executer des commandes. Demain, il accede a ta base de donnees, ton monitoring, ton backlog, ton CI/CD — tout via des serveurs MCP. L'ecosysteme se structure.

Des workflows multi-agents. Un agent qui code, un autre qui review, un troisieme qui teste. Chacun specialise. C'est deja possible techniquement (Anthropic Agent SDK, CrewAI), mais pas encore fiable pour la production. Ca viendra.

Mais le fondamental ne change pas : tu dois comprendre le code pour le reviewer. Si tu ne comprends pas ce que l'agent produit, tu ne peux pas valider. L'IA ne remplace pas la competence technique — elle l'amplifie.

Ressources

• Claude Code — documentation officielle — reference pour configurer et utiliser Claude Code
• Cursor — IDE avec IA integree, bon point d'entree
• CLAUDE.md best practices — guide pour ecrire un bon fichier de contexte
• Anthropic Agent SDK — pour construire tes propres agents
• MCP — Model Context Protocol — le standard de connexion agent-outils

Cet article fait partie de la serie "Comprendre l'IA en 2026".

• Article precedent : Les agents IA ne sont pas du hype
• Voir aussi : RAG, MCP, function calling — le kit du dev en 2026
• Article suivant : Rattraper 3 ans d'IA en 8 semaines