Maîtriser Claude Code

Un agent n'est à la hauteur que de ce que vous lui donnez

Un modèle répond à partir de ce qu'il peut voir. Donnez-lui les bons faits, la bonne quantité de réflexion, un moyen de prouver son travail et des limites claires, et il fournit un résultat. Omettez-en un, et il devine avec assurance.

Quatre questions traversent tout l'atelier :

• Contexte. L'agent dispose-t-il des bons faits ?
• Raisonnement. Cette tâche justifie-t-elle un modèle plus important ou davantage d'effort ?
• Preuve. Qu'est-ce qui prouve que le résultat est correct ?
• Autonomie. Vos contrôles et vos limites donnent-ils le droit de s'éloigner ?

Vous apprenez à y répondre avec Claude Code, en quatre étapes. Chaque étape est une ceinture, et chaque ceinture se termine par quelque chose qui fonctionne.

Quatre ceintures

• Ceinture blanche, bases. Ce qu'est un modèle, ce que fait l'environnement qui l'entoure, votre première conversation avec Claude Code.
• Ceinture bleue, construire CLASH. D'une spécification à une application en fonctionnement : planifier d'abord, travailler par petites étapes, laisser Claude regarder la page, revoir comme un inconnu.
• Ceinture marron, contrôler le contexte. Rédiger un CLAUDE.md à partir de règles réelles, encapsuler une habitude sous forme de skill, auditer avec des subagents, transformer une histoire en spécification, limiter des règles à des chemins.
• Ceinture noire, orchestrer et lâcher prise. Les tests comme ligne d'arrivée, équipes d'agents et dynamic workflows, hooks, le navigateur comme contrôle, worktrees et CI, le Agent SDK, travail planifié et en arrière-plan, votre propre serveur MCP.

Une vraie application

Vous construisez CLASH, une application cartographique pour des rencontres spontanées à Berlin. Un clash est une activité à un lieu et à une heure. Les participants rejoignent, les hôtes acceptent ou refusent, les notifications suivent. Vous partez d'une spécification et d'un dépôt vide. CLASH est en ligne et gratuit, vous pouvez donc l'essayer avant de le construire vous-même.

Le vrai code comporte de vraies erreurs : une Server Action qui ignore une vérification de propriété, une carte qui plante sur le serveur, un avatar qui ralentit chaque page. Vous les trouvez et vous les corrigez avec des preuves.

À la fin, vous avez :

• CLASH, construit par vous avec Claude Code et comparé à la référence
• un CLAUDE.md fondé sur de vraies règles, un skill réutilisable et un ensemble de hooks
• un audit d'autorisation exécuté de trois façons, avec le correctif fusionné
• une suite de tests navigateur et un correctif de performance mesuré
• l'audit exécuté dans CI, un flux de worktree et un petit programme Agent SDK
• Claude Code fonctionnant sans personne au clavier : un style de sortie, un objectif, une boucle, une session en arrière-plan et une routine
• votre propre serveur MCP sur CLASH, et une deuxième application qui publie ses conférences comme clashes à travers celui-ci

Déroulement

Le formateur explique une idée, la montre en direct, puis vous la mettez en pratique sur votre propre machine. Chaque tâche dispose d'une branche de réinitialisation, afin que personne ne reste bloqué et que personne n'attende le groupe. Les slides, les fichiers de tâche et les corrigés vous appartiennent.

Public visé

Toute personne qui programme et souhaite bien utiliser Claude Code. Des bases de programmation dans un langage courant suffisent, ainsi que les bases de git. L'application que vous construisez, CLASH, est écrite en TypeScript. Vous n'avez pas besoin de le connaître : si vous savez lire du code dans un autre langage, vous pouvez suivre, et Claude Code explique ce qui est nouveau. Aucune expérience de Claude Code n'est requise.

Ce dont vous avez besoin

Un ordinateur portable avec Node.js 20.19 ou plus récent, git et la GitHub CLI. Un compte Claude avec accès à Claude Code : Pro convient, une offre supérieure laisse plus de marge pour la tâche d'équipe d'agents. Un compte GitHub. La checklist complète d'installation vous attend sur votre page d'atelier une fois votre inscription effectuée.

Ceinture blanche : bases

Vous apprenez ce qu'est un modèle, ce que fait l'environnement qui l'entoure, et comment maintenir une conversation sur la bonne voie.

1. Comment fonctionne un modèle. Tokens, probabilités, pas de mémoire et une fenêtre de contexte limitée : ce qu'est un modèle de langage, pourquoi il devine, et pourquoi Claude Code place des fichiers devant lui.
2. L'environnement et votre première conversation. Ce que Claude Code ajoute autour du modèle : la boucle, le prompt, les outils et les permissions. Ensuite, vous le démarrez dans un projet et posez une question sur un fichier.
   Tâche : Configurer Claude Code et poser votre première question.

Ceinture bleue : construire CLASH

Vous passez d'une spécification à une application en fonctionnement, une petite étape à la fois.

3. Planifier avant de construire. Rédiger un brief avec un objectif, des règles et une ligne d'arrivée, et utiliser le mode plan pour revoir un changement difficile à annuler avant que Claude n'écrive un seul fichier.
   Tâche : Générer la structure de l'application et planifier son modèle de données.
4. Petites étapes et moment de sécurité. Construire par petites étapes que vous pouvez vérifier, en annuler une avec /rewind, surveiller la fenêtre de contexte et comprendre pourquoi chaque Server Action a besoin de sa propre vérification de propriété.
   Tâche : Construire la connexion et les clashes par petites étapes.
5. Laisser Claude voir le résultat. Réutiliser un schéma en le pointant, donner à Claude l'erreur ou la page en direct au lieu de décrire un bug, et ajouter des garde-fous qualité à CLAUDE.md.
   Tâche : Construire les lieux, la carte et les notifications.
6. Travaux parallèles, mémoire et revue. Regrouper des travaux indépendants dans un même brief, exécuter du travail en arrière-plan, enregistrer une règle en mémoire, revoir votre propre diff comme un inconnu et livrer via Claude.
   Tâche : Finaliser l'application, la revoir et la livrer.

Ceinture marron : contrôler le contexte

Vous décidez ce que Claude sait, quand il le charge et qui vérifie le travail.

7. Contexte et CLAUDE.md. Lire /context, rédiger un CLAUDE.md à partir de six règles réelles de CLASH, et revoir un plan en mode plan avant toute modification de code.
   Tâche : Rédiger un CLAUDE.md à partir de règles réelles et revoir un plan.
8. Skills et plugins. Rédiger un skill pour une recette que vous répétez, vérifier ce que les skills coûtent en contexte, et l'encapsuler comme plugin que vous pouvez partager.
   Tâche : Rédiger le skill clash-feature et livrer les favoris de lieux avec celui-ci.
9. Subagents pour les audits. Confier un audit à un subagent en lecture seule afin que votre propre contexte bouge à peine, et distinguer un subagent frais d'un fork.
   Tâche : Auditer les Server Actions avec un subagent en lecture seule.
10. De l'histoire à la spécification. Transformer une histoire vague en spécification stabilisée avec Example Mapping, exécuté comme skill qui vous interroge avant de rédiger.
    Tâche : Construire le skill discover et enregistrer une spécification stabilisée.
11. Règles limitées par chemin. Limiter une règle de projet à app/actions/** avec un frontmatter paths:, puis vérifier dans /context qu'elle ne se charge que sur une lecture correspondante.
    Tâche : Rédiger une règle limitée par chemin pour les Server Actions.

Ceinture noire : orchestrer et lâcher prise

Vous ajoutez des tests, des équipes, des hooks et un navigateur comme contrôles, puis vous vous éloignez délibérément.

12. La boucle interne pilotée par les tests. Piloter le code à partir d'une spécification enregistrée, une règle à la fois, et encapsuler la boucle rouge-vert-refactor en skill qui s'arrête de lui-même.
    Tâche : Piloter les règles de capacité avec un skill TDD.
13. Équipes d'agents et dynamic workflows. Décrire une équipe d'agents et un dynamic workflow avec des mots simples, lire le script généré, et choisir la bonne stratégie pour un travail.
    Tâche : Exécuter l'audit de propriété en équipe et comme workflow.
14. Hooks et sécurité. Transformer une règle répétée en hook qui bloque, avertit ou maintient un tour ouvert, et apprendre où s'arrête la portée de Claude dans vos fichiers.
    Tâche : Construire quatre hooks Claude Code.
15. Le navigateur boucle la boucle. Laisser Claude piloter un vrai navigateur via MCP, écrire le test une fois le flux fonctionnel, et prouver un correctif avec une mesure avant et après.
    Tâche : Tester le flux d'inscription et corriger la charge utile de l'avatar.
16. Worktrees, batch et CI. Exécuter des agents côte à côte dans des worktrees séparés, savoir quand /batch convient, et exécuter le même audit dans CI sur chaque pull request.
    Tâche : Exécuter deux worktrees et auditer chaque pull request.
17. Le Agent SDK. Exécuter la boucle d'agent Claude Code dans votre propre programme avec des outils en lecture seule, un hook et une limite de tours.
    Tâche : Héberger la boucle d'agent dans votre propre programme.
18. Projet final. Livrer une fonctionnalité sur le CLASH de référence sous forme de pull request, en utilisant ensemble tous les outils de l'atelier.
    Tâche : Livrer une fonctionnalité avec tous les outils de l'atelier.
19. Personne au clavier. Définir un style de sortie, borner une exécution avec /goal, boucler un contrôle, exécuter un audit en arrière-plan et voir une routine cloud.
    Tâche : Exécuter Claude Code sans personne au clavier.
20. Construire votre propre serveur MCP. Concevoir un serveur MCP avec quatre outils sur la base de données CLASH, lui faire confiance de manière sélective et l'appeler depuis une deuxième application.
    Tâche : Concevoir un serveur MCP pour CLASH.