Installer Claude Code prend cinq minutes. Le faire travailler correctement dans une équipe de cinq développeurs prend beaucoup plus longtemps, et ce n'est pas une question de prompt. Les équipes qui butent sur l'outil butent presque toujours aux mêmes endroits : un agent qui ne respecte pas les conventions du projet, des droits trop larges ou trop étroits, des diffs énormes que personne ne relit vraiment.
Une formation Claude Code utile ne montre donc pas « comment parler à l'IA ». Elle apprend à une équipe à configurer, encadrer et relire un agent qui écrit du code dans ses dépôts. Ce guide décrit ce qu'il faut apprendre, dans quel ordre, et pourquoi la formation se fait sur votre code plutôt que sur un projet de démonstration.
Ce qu'une formation Claude Code doit vraiment couvrir
Claude Code n'est pas un assistant de complétion. C'est un agent : il lit des fichiers, lance des commandes, modifie le code et enchaîne les étapes jusqu'à ce que la tâche soit faite. Cette différence change ce qu'il faut apprendre.
Avec un outil de complétion, le développeur reste aux commandes à chaque ligne. Avec un agent, il délègue une tâche entière et récupère un résultat. Les compétences qui comptent se déplacent :
- décrire une tâche de façon à ce qu'elle soit faisable sans aller-retour ;
- donner le contexte du projet une fois pour toutes, au lieu de le répéter à chaque session ;
- fixer ce que l'agent a le droit de faire, et le rendre impossible quand c'est critique ;
- relire un diff produit par un agent, qui ne se relit pas comme celui d'un collègue.
Une formation qui passe sa journée sur les formulations de prompt rate l'essentiel. Le prompt compte, mais il pèse peu à côté de la configuration du projet. Un bon prompt dans un dépôt mal configuré produit du code correct qui ne ressemble pas au reste du projet.
Les quatre briques à maîtriser
1. Le fichier CLAUDE.md : la mémoire du projet
C'est le premier sujet, et le plus rentable. CLAUDE.md est un fichier Markdown à la racine du dépôt, que Claude Code lit au début de chaque session. On y met les commandes du projet (installer, lancer, tester), l'architecture en quelques lignes, les conventions qui ne se devinent pas et les pièges connus.
En formation, on ne se contente pas de l'expliquer : chaque équipe écrit le sien, sur son dépôt, et le teste immédiatement. La commande /init génère un premier jet à partir du code. L'exercice consiste ensuite à y ajouter ce que le code ne dit pas : la librairie de dates imposée, la langue des commentaires, la migration qu'on ne touche jamais.
La règle qu'on fait retenir : chaque fois qu'on corrige l'agent deux fois sur le même point, la correction va dans le fichier. Nous détaillons le contenu type et un modèle prêt à copier dans notre guide pour écrire un bon fichier CLAUDE.md.
2. Les permissions : ce que l'agent peut faire sans demander
Par défaut, Claude Code demande confirmation avant les actions sensibles : modifier un fichier, lancer une commande. C'est sûr, mais vite pénible. Le réflexe naturel est de tout accepter. C'est là que les incidents commencent.
La formation apprend à régler les permissions dans les fichiers de configuration du projet :
- ce qui est autorisé sans confirmation : lancer les tests, le linter, la vérification de types ;
- ce qui demande toujours confirmation : installer une dépendance, toucher à la configuration ;
- ce qui est refusé : lire les fichiers de secrets, pousser sur la branche principale.
Le point important est la distinction entre configuration partagée et configuration personnelle. Les règles de l'équipe sont versionnées avec le code et passent en revue comme le reste. Les préférences d'un développeur restent sur sa machine. Une équipe qui ne fait pas cette distinction finit avec autant de réglages que de postes, et plus personne ne sait ce que l'agent a le droit de faire.
3. Les hooks : les garde-fous qui ne dépendent pas de l'agent
Une consigne écrite dans CLAUDE.md est une consigne. L'agent la suit dans la grande majorité des cas, mais rien ne l'y oblige mécaniquement. Pour ce qui ne doit jamais arriver, il faut un verrou.
Les hooks sont ce verrou. Ce sont des scripts que Claude Code exécute à des moments précis : avant l'appel d'un outil, après une modification de fichier, à la fin d'une tâche. Un hook placé avant une commande peut la bloquer. Un hook placé après une modification peut lancer le formateur ou les tests automatiquement.
En formation, on écrit deux ou trois hooks réels sur le dépôt de l'équipe. Les plus fréquents :
- formater automatiquement chaque fichier modifié, pour ne plus jamais voir de diff de style en revue ;
- bloquer toute commande qui touche à un fichier d'environnement ;
- refuser une commande destructive sur la base de données locale.
C'est souvent la partie qui convainc les responsables techniques. Elle transforme « on espère que l'agent respecte la règle » en « l'agent ne peut pas enfreindre la règle ».
4. La revue : relire ce qu'un agent a écrit
Un diff produit par un agent ressemble à celui d'un développeur compétent. C'est précisément le problème : il inspire confiance. Ses erreurs ne sont pas des fautes de syntaxe, ce sont des choix plausibles mais faux. Une fonction utilitaire réécrite alors qu'elle existait déjà dans le projet. Un test modifié pour passer au lieu du code corrigé. Une gestion d'erreur qui avale silencieusement l'exception.
La formation apprend une grille de relecture spécifique :
- les tests ont-ils été modifiés ? Si oui, pourquoi, et est-ce légitime ;
- le diff fait-il plus que la tâche ? Un agent qui « en profite » pour refactorer ailleurs alourdit la revue ;
- le code réutilise-t-il l'existant ? Ou a-t-il recréé ce que le projet avait déjà ;
- les cas d'erreur sont-ils traités, ou seulement le chemin heureux.
On apprend aussi à garder des tâches de taille relisible. Une tâche qui produit un diff de deux mille lignes ne sera pas relue, quelle que soit la bonne volonté de l'équipe. Mieux vaut cinq tâches de quatre cents lignes.
Savoir découper et décrire une tâche
C'est la compétence la plus sous-estimée. La plupart des déceptions avec Claude Code viennent de tâches mal posées, pas d'un modèle qui raisonne mal.
Une tâche bien posée tient en quelques lignes et contient trois choses : ce qu'il faut obtenir, où regarder, et comment vérifier que c'est fait. « Ajoute un filtre par date sur la liste des factures, sur le modèle du filtre par client dans le même composant, et vérifie avec les tests du dossier factures » se traite en une passe. « Améliore la page factures » produit un résultat imprévisible.
La formation insiste aussi sur le mode plan. Avant d'écrire du code, on demande à l'agent de proposer une démarche, on la corrige, puis on le laisse exécuter. Sur une tâche qui touche plusieurs fichiers, cette étape évite la majorité des allers-retours.
Dernier réflexe à prendre : savoir repartir de zéro. Une session longue accumule du contexte, et un agent qui a fait fausse route a tendance à s'y tenir. Effacer la conversation et reformuler la tâche est souvent plus rapide que corriger pas à pas.
Pourquoi former sur vos propres dépôts
Un projet de démonstration est propre, petit et bien documenté. Claude Code y brille. Votre dépôt, lui, a des années d'historique, des conventions implicites, un dossier que personne n'ose toucher et des tests qui échouent par intermittence. C'est là que l'agent se trompe, et c'est donc là qu'il faut apprendre à le corriger.
Former sur les dépôts de l'équipe a trois effets concrets.
La configuration produite reste. À la fin de la formation, le CLAUDE.md, les permissions et les hooks sont committés dans le dépôt. Ils ne sont pas restés dans un support de cours : ils travaillent dès le lendemain.
Les pièges sont les vrais. Quand l'agent bute sur la migration particulière du projet ou sur l'outil de build maison, la correction est utile tout de suite. Sur un projet d'exemple, on ne rencontre jamais ces cas.
Les tâches sont celles du backlog. Les exercices sont des tickets réels, choisis avec l'équipe. Le temps de formation produit déjà du code livrable.
Cela suppose une condition à régler avant la première session : le code de vos dépôts est envoyé au modèle pendant le travail. Vérifiez avec votre direction technique et, si besoin, votre service juridique, que le contrat et les réglages de confidentialité de votre compte correspondent à vos exigences. C'est une question de configuration du compte, pas une raison d'écarter l'outil, mais elle se traite avant et pas après.
Le format qu'on recommande
Une journée de présentation devant des slides ne rend personne autonome. Ce qui fonctionne, c'est une alternance entre sessions de travail guidées et périodes d'usage réel.
Première session : configurer. On installe l'outil sur les postes, on écrit le CLAUDE.md du dépôt principal, on règle les permissions partagées. L'équipe repart avec un dépôt prêt.
Période d'usage. L'équipe travaille avec Claude Code sur ses tickets habituels pendant une à deux semaines. Chacun note ce qui a coincé : l'agent qui ignore une convention, une commande bloquée pour rien, une revue difficile.
Deuxième session : corriger et verrouiller. On reprend la liste des frictions. Les conventions ignorées vont dans le CLAUDE.md, les risques réels deviennent des hooks, les permissions sont ajustées. C'est la session la plus productive, parce qu'elle part de problèmes vécus.
Troisième session : aller plus loin. Selon les besoins de l'équipe : des commandes personnalisées pour les tâches répétitives, la connexion à des outils internes via MCP, ou l'exécution de Claude Code sans terminal, dans l'intégration continue, pour la revue automatique ou la préparation de tâches. Ce dernier usage demande ses propres garde-fous, que nous décrivons dans notre retour d'expérience sur les runs autonomes.
Le format exact s'adapte à la taille de l'équipe et à l'état des dépôts. C'est ce qu'on construit dans nos formations IA en entreprise quand le sujet est Claude Code.
Comment savoir que l'équipe est autonome
L'autonomie ne se mesure pas au nombre de développeurs qui ont installé l'outil. Quatre signes la montrent, et ils se vérifient dans le dépôt.
- Le
CLAUDE.mdévolue sans vous. Des commits réguliers, par plusieurs personnes, qui ajoutent des pièges et retirent ce qui ne vaut plus. - Les permissions sont dans le dépôt, relues en revue, et personne ne travaille en acceptant tout.
- Les pull requests produites avec l'agent ont une taille relisible, et la revue y trouve encore des choses : signe qu'elle est faite.
- L'équipe sait dire non à l'outil. Elle sait quelles tâches elle ne lui confie pas, et pourquoi.
Si ces quatre points tiennent après quelques semaines, la formation a fait son travail. S'ils ne tiennent pas, le problème est rarement l'outil. C'est presque toujours une configuration restée dans la tête d'une seule personne.
Former ou se faire accompagner
Une formation rend l'équipe capable d'utiliser Claude Code sur ses projets. Elle ne remplace pas un accompagnement quand l'objectif est plus large : faire tourner un agent sans personne devant l'écran, reprendre un dépôt ancien, ou livrer un projet avec un délai serré. Dans ces cas, on travaille directement dans le code avec l'équipe, ce que nous décrivons sur notre page agence Claude Code.
Les deux se combinent souvent. On monte la configuration et les premiers garde-fous en travaillant sur le projet, puis on forme l'équipe à les faire vivre. L'objectif reste le même : que l'équipe n'ait plus besoin de nous pour s'en servir.
















