Formation Claude Code : développer avec un agent dans son terminal

Jour 1 : installer, cadrer, produire

1. Le coding agentique et la place de Claude Code

• Ce qui distingue un agent d'une complétion dans l'éditeur : il lit, exécute, corrige, recommence.
• Panorama des approches du marché et de leurs partis pris.
• Les tâches où le gain est immédiat, celles où la relecture coûte plus cher que le gain.
• Les modèles disponibles et le choix selon la tâche.
• Atelier : inventaire des tâches de votre équipe classées par intérêt réel.

2. Installation et première session

• Installation, authentification, vérification de la version et du modèle actif.
• Le terminal, l'éditeur, les modes d'interaction disponibles.
• Lancer l'agent sur un dépôt existant et lui faire décrire l'architecture qu'il découvre.
• Atelier : installation complète et première exploration d'un dépôt inconnu.

3. La mémoire projet

• Le fichier de mémoire : pile technique, conventions de code, branche par défaut, règles à ne jamais enfreindre.
• Mémoire projet et mémoire personnelle : ce qui se partage dans le dépôt, ce qui reste local.
• Écrire des règles que l'agent respecte vraiment, et vérifier qu'il les applique.
• Faire vivre ce fichier au rythme du projet.
• Atelier : rédaction du fichier de mémoire de votre projet, puis test de conformité sur une modification.

4. Permissions et sécurité

• Le fichier de réglages : autoriser, demander, refuser, outil par outil.
• Ce qu'un agent ne doit jamais pouvoir faire sans validation humaine.
• Secrets, variables d'environnement et fichiers à exclure du contexte.
• Exécution isolée et garde-fous sur les commandes destructrices.
• Atelier : construction d'un jeu de permissions pour votre équipe, puis test des refus.

5. Le quotidien : explorer, comprendre, modifier

• Parcourir un dépôt : recherche, lecture, cartographie, sans rien modifier.
• Diagnostiquer un défaut : reproduction, cause racine, correctif ciblé.
• Générer et modifier des fichiers en gardant la main sur chaque différence.
• Faire produire les tests manquants et les exécuter.
• Atelier : correction d'un défaut réel, du diagnostic au test qui passe.

6. Git et gestion du contexte

• Commits structurés, branches, résolution de conflits assistée.
• Préparer une demande de fusion lisible par un humain.
• Le contexte : ce que l'agent garde, ce qu'il oublie, ce qu'il coûte.
• Compacter une session longue, la repartir, savoir quand tout recommencer.
• Atelier : session longue menée jusqu'à la demande de fusion, avec pilotage du contexte.

Jour 2 : industrialiser

7. Le cycle explorer, planifier, coder, livrer

• Faire produire un plan avant toute modification, et le corriger avant de lancer.
• Découper une fonctionnalité en étapes vérifiables une à une.
• Reprendre la main en cours de route sans perdre le travail engagé.
• Atelier : fonctionnalité complète menée selon ce cycle, du besoin à la livraison.

8. Commandes personnalisées et hooks

• Créer ses propres commandes pour les gestes répétés de l'équipe.
• Les hooks : déclencher un contrôle avant ou après chaque action de l'agent.
• Brancher un outil de formatage de code, un analyseur statique, une vérification de conventions.
• Partager ces automatismes dans le dépôt pour que toute l'équipe en hérite.
• Atelier : création d'une commande de revue de code et d'un hook qui lance votre analyseur.

9. Sous-agents et tâches parallèles

• Déléguer une sous-tâche à un agent dédié avec son propre contexte.
• Traiter en parallèle ce qui peut l'être, rassembler les résultats.
• Les cas où la parallélisation fait perdre du temps.
• Atelier : refactorisation répartie entre plusieurs sous-agents.

10. MCP : relier l'agent à votre système d'information

• Le protocole : donner un accès contrôlé à un outil externe, en lecture ou en écriture.
• Connecteurs utiles à une équipe technique : suivi de tickets, documentation, base de données, dépôt distant, supervision.
• Installer un serveur, restreindre ses droits, vérifier ce qu'il expose réellement.
• Quand écrire son propre serveur, et ce que cela représente.
• Atelier : mise en place d'un connecteur et usage dans une tâche de développement réelle.

11. Mode non interactif et intégration continue

• Lancer l'agent sans interaction, en récupérant un résultat exploitable par un script.
• Revue automatisée des demandes de fusion, rédaction de journaux de version, correctifs répétitifs.
• Les garde-fous indispensables dans un pipeline : périmètre, validation humaine, traçabilité.
• Atelier : ajout d'une étape d'analyse automatisée dans une chaîne d'intégration continue.

12. Coûts, limites et adoption en équipe

• Ce qui consomme, ce qui coûte cher, les leviers de réduction concrets.
• Les limites actuelles : ce que l'agent fait mal, ce qu'il ne faut pas lui confier.
• Revue de code et responsabilité : qui signe ce qui est livré.
• Introduire l'outil dans une équipe : périmètre de départ, règles communes, mesure du gain.
• Atelier final : rédaction de la charte d'usage et du plan de déploiement de votre équipe.