Programme complet

La formation Claude Code, de zéro à autonome en 41 parcours

Une formation en ligne, en français, pour apprendre à construire, corriger, tester et livrer de vrais projets avec Claude Code, même si tu pars de zéro.

• 41 parcours
• 209 leçons
• 200 exercices
• environ 45 h
• 59 € TTC · paiement unique
• Parcours 0 gratuit

Découvrir l’Accès Fondateur — 59 €

220 questions de quiz. L'ordre des parcours est libre (ils sont numérotés dans l'ordre conseillé), mais les contenus premium nécessitent l'Accès Fondateur. Le parcours 0 est gratuit, sans compte. Découvrir la méthode CCODE LAB

1. Parcours 0 — Avant de commencer : Terminal, shell, dossier, chemin, port, API, Git, tokens, hallucination… Trente mots que tout le monde emploie comme si tu les connaissais. Ici, on les explique un par un, avec un exemple concret et une manipulation dans le terminal d’entraînement.
2. Parcours 1 — Installation : Installer proprement chaque outil, savoir vérifier que ça marche, diagnostiquer quand ça ne marche pas, mettre à jour, et désinstaller sans laisser de traces. Commandes vérifiées contre la documentation officielle.
3. Parcours 2 — Le terminal, de zéro à autonome : Toutes les commandes dont tu auras besoin pendant des mois, avec leur version macOS/Linux et Windows, un exemple, les pièges, et une mission dans le terminal d’entraînement à chaque leçon. Les commandes destructrices sont traitées à part, sans les minimiser.
4. Parcours 3 — Premiers pas avec Claude Code : Ta première vraie session, décomposée geste par geste : ce que Claude Code voit, comment lui parler, comment lire ce qu’il propose, comment garder la main. Des exercices ultra simples, sur ton vrai terminal, avec un dossier de test.
5. Parcours 4 — Bien donner des instructions : Pourquoi deux demandes proches donnent deux résultats très différents, et comment écrire, à chaque fois, celle qui tombe juste. Beaucoup d’exemples avant/après, sur des cas réels.
6. Parcours 5 — CLAUDE.md et mémoire de projet : Chaque session repart d’un contexte vide. CLAUDE.md est ce que Claude Code relit à chaque fois. Ce parcours t’apprend à l’écrire court et efficace, à le découper en règles, à distinguer les niveaux (utilisateur, projet, local) et à comprendre la mémoire automatique.
7. Parcours 6 — Comprendre une codebase : Reprendre un projet que tu n’as pas écrit est le cas le plus fréquent en réalité. Ce parcours t’apprend à faire cartographier le projet par Claude Code, à suivre un flux de données de l’écran à la base, et à localiser un bug ou un morceau de code inconnu sans te perdre.
8. Parcours 7 — HTML : lire la structure : Tu n’écriras pas beaucoup de HTML toi-même, mais tu le liras tous les jours. Balises, attributs, imbrication, sémantique, formulaires, accessibilité, DOM : les notions qui suffisent pour collaborer intelligemment avec l’IA et repérer ses erreurs.
9. Parcours 8 — CSS : lire et retoucher une mise en page : Assez de CSS pour comprendre pourquoi une page ressemble à ce qu’elle est, retoucher une valeur sans tout casser, et cadrer les demandes de mise en page à Claude Code. Chaque leçon se termine par une retouche dans l’inspecteur puis une demande précise.
10. Parcours 9 — JavaScript : reconnaître ce qui se passe : Ne pas paniquer devant un fichier .js. Suivre un clic jusqu’à son effet, savoir où est la logique, décrire un comportement attendu plutôt qu’écrire le code. Chaque notion est illustrée par du code que Claude Code produit réellement.
11. Parcours 10 — TypeScript : des garde-fous pour l’IA : TypeScript ajoute des types à JavaScript : le code déclare la forme des données, et un vérificateur signale les incohérences avant l’exécution. Avec une IA qui écrit du code, c’est le filet de sécurité le plus rentable qui existe. Ce parcours t’apprend à le lire et à exploiter ses erreurs.
12. Parcours 11 — Git : ne jamais perdre son travail : Git est ton bouton « annuler » universel — à condition de l’utiliser avant la catastrophe. Ce parcours couvre le quotidien, les branches, les retours en arrière sûrs et dangereux (sans les minimiser), les conflits, et les bonnes pratiques avec une IA qui modifie beaucoup de fichiers.
13. Parcours 12 — GitHub : sauvegarder, partager, relire : Git chez toi, GitHub en ligne : sauvegarde distante, collaboration, revue de code, automatisation. Ce parcours couvre le nécessaire pour publier proprement un projet, y compris ce que Claude Code sait faire avec la CLI gh.
14. Parcours 13 — Déboguer avec Claude Code : La compétence la plus rentable de la formation. Une méthode en huit étapes, puis les familles d’erreurs une par une : npm, TypeScript, build, navigateur, API, réseau, CORS, base de données, authentification, environnement, Git, déploiement. Avec des exercices où quelque chose casse volontairement.
15. Parcours 14 — Tests : voir passer, pas croire : Un test vu passer vaut plus que mille « ça marche ». Ce parcours t’apprend à lire un test, à en faire écrire par Claude Code avant le code, à casser volontairement pour vérifier que les tests attrapent, et à ne pas confondre couverture et qualité.
16. Parcours 15 — Créer un site complet : Un projet guidé de bout en bout : du brief client à la mise en ligne. Tu diriges Claude Code étape par étape, avec les vérifications d’un professionnel à chaque lot. Ce parcours prépare les projets 2 et 3.
17. Parcours 16 — Créer une application : Passer du site à l’application : un backend qui reçoit, valide, enregistre et répond ; un frontend qui affiche et réagit. Ce parcours pose l’architecture et la méthode ; les parcours 17 à 20 approfondissent chaque brique. Il prépare les projets 5 et 6.
18. Parcours 17 — Bases de données : Ranger des données de façon fiable : le modèle, le langage SQL, les migrations qui font évoluer la structure sans perdre de données, l’ORM qui traduit, et les règles de sécurité. Prépare le projet 7.
19. Parcours 18 — API : concevoir, consommer, protéger : Une API bien conçue est un contrat que le frontend, les partenaires et l’IA peuvent respecter. Ce parcours couvre la conception REST, la consommation d’API tierces, les webhooks entrants, les limites de débit, et les erreurs — des deux côtés du réseau.
20. Parcours 19 — Authentification : Savoir qui est en face, sans se faire pirater. Les mécanismes (sessions, cookies, JWT, OAuth), les règles non négociables sur les mots de passe, et le choix entre bibliothèque, service et fait maison. Prépare le projet 8.
21. Parcours 20 — Services externes : Un produit réel dépend de services tiers. Ce parcours apprend à les choisir, à lire leur documentation avec Claude Code, à gérer leurs clés, à tester en mode sandbox, et à préparer l’intégration d’un paiement (Stripe) sans exposer un seul secret.
22. Parcours 21 — MCP : connecter Claude Code au monde : Le Model Context Protocol permet à Claude Code d’utiliser des outils externes : GitHub, une base de données, une documentation, un navigateur. Ce parcours explique ce qu’est un serveur MCP, comment l’ajouter (et à quelle portée), comment vérifier qu’il fonctionne, et pourquoi chaque serveur est une décision de confiance.
23. Parcours 22 — Agents, sous-agents et workflows : Quand une tâche devient longue ou répétitive, Claude Code permet de la structurer : des skills réutilisables, des sous-agents spécialisés avec leur propre contexte, des tâches en arrière-plan, des sessions parallèles. Ce parcours apprend à les créer, à les cadrer, et à garder la relecture humaine au centre.
24. Parcours 23 — Hooks et automatisation : Un hook est un script (ou une requête) que Claude Code lance à un moment précis : avant d’exécuter une commande, après avoir modifié un fichier, quand une session démarre. Ce parcours apprend à formater automatiquement, à bloquer les commandes dangereuses, à journaliser, et à ne jamais transformer un hook en porte dérobée.
25. Parcours 24 — Permissions et sécurité de Claude Code : Claude Code est puissant parce qu’il agit sur ta machine. Ce parcours explique en profondeur le système qui encadre ces actions : les modes de permission (manuel, acceptEdits, plan, auto, bypass), la syntaxe des règles et leur ordre d’évaluation, la confiance du dossier, les chemins protégés et critiques, le sandbox, et une méthode pour configurer un projet en sécurité.
26. Parcours 25 — Gestion du contexte : La fenêtre de contexte est la mémoire de travail de Claude : tout ce qu’il sait de ta session tient dedans. Ce parcours explique ce qui la remplit, comment la lire (/context), quand la nettoyer (/clear), la compacter (/compact), reprendre ou brancher une session, et comment organiser le travail pour que les instructions importantes ne se perdent jamais.
27. Parcours 26 — Réduire les erreurs de l’IA : Un modèle de langage produit du texte plausible, pas du texte vrai. Ce parcours catalogue les erreurs typiques (invention d’API, tests complaisants, portée qui déborde, confiance excessive), explique d’où elles viennent, et construit une méthode : donner à Claude un moyen de vérifier, travailler par petites étapes, relire le diff, tester, et garder la décision. « L’IA propose. Le développeur vérifie. »
28. Parcours 27 — Prompt engineering pour développeurs : Au-delà des bases du parcours 4, ce parcours approfondit l’art de la demande en contexte de code : structure en cinq blocs, contexte par mention et par fichier, critères de réussite vérifiables, format de sortie imposé, demandes de plan et de critique, exemples (few-shot), décomposition, et une bibliothèque de prompts pour les situations courantes.
29. Parcours 28 — Refactoring : Refactoriser, c’est changer la structure sans changer le comportement. Ce parcours donne la discipline (tests verts avant et après, petits pas, un objectif par commit), les refactorings les plus rentables, et la façon de les déléguer à Claude Code sans qu’il en profite pour tout réécrire.
30. Parcours 29 — Performance : La performance se mesure, ne se devine pas. Ce parcours apprend à lire Lighthouse et les Web Vitals, à repérer les causes classiques de lenteur côté navigateur et côté serveur (images, JavaScript, N+1, absence d’index), à appliquer les optimisations rentables, et à faire faire le travail à Claude Code sur des mesures, pas sur des intuitions.
31. Parcours 30 — Accessibilité : L’accessibilité n’est pas une option : c’est une obligation légale pour beaucoup de sites, et surtout la condition pour que des millions de personnes puissent utiliser ce que tu construis. Ce parcours couvre les principes (WCAG), les gestes qui règlent 80 % des problèmes (HTML sémantique, clavier, contraste, formulaires, images), les outils de vérification, et comment obtenir de Claude Code du code accessible par défaut.
32. Parcours 31 — SEO : Le référencement naturel commence par un site que les moteurs peuvent lire et comprendre. Ce parcours couvre le SEO technique (balises, structure, sitemap, robots, données structurées, rendu), les bases du contenu, la mesure (Search Console), et une méthode de vérification — sans promesses magiques.
33. Parcours 32 — Déploiement : Un projet qui tourne sur ta machine n’existe pas pour le monde. Ce parcours explique comment un site ou une application arrive en ligne : les types d’hébergement, la commande de build, les variables d’environnement de production, le nom de domaine et HTTPS, les environnements de prévisualisation, le retour arrière, et une liste de contrôle avant chaque mise en production.
34. Parcours 33 — CI/CD : L’intégration continue re-vérifie chaque pull request sur une machine propre : typecheck, lint, tests, build. Le déploiement continu enchaîne la mise en ligne quand tout est vert. Ce parcours construit un pipeline GitHub Actions de zéro, protège la branche principale, et montre comment intégrer Claude Code (revue automatique, @claude) sans lui donner les clés de la production.
35. Parcours 34 — Reprendre un projet existant : Le cas le plus fréquent en réalité : un projet existant, parfois sans documentation, parfois sans tests, souvent avec des surprises. Ce parcours donne la méthode en quatre temps — faire tourner, cartographier, poser un filet, puis modifier par petites touches — et les demandes Claude Code qui accélèrent chaque temps sans prendre de risque.
36. Parcours 35 — Projet professionnel complet : Ce parcours prépare le projet 10 (un SaaS complet) : il enseigne la partie qui n’est pas du code — comprendre un besoin, écrire un cahier des charges, découper en lots livrables, estimer, tenir un rythme, démontrer, livrer et documenter. Avec Claude Code comme accélérateur à chaque étape, et l’humain comme responsable de chaque décision.
37. Parcours 36 — Maintenance et suivi client : Un projet livré commence sa vraie vie. Ce parcours couvre la maintenance : surveillance (erreurs, disponibilité, journaux), traitement des incidents, mises à jour de sécurité, sauvegardes et restauration testée, et la relation client — contrat de maintenance, priorités, communication — avec Claude Code comme assistant de diagnostic et de routine.
38. Parcours 37 — Freelance et clients : Construire vite avec Claude Code change l’économie du freelance : ce parcours traite ce que ça implique côté commercial et juridique — comment présenter son offre, faire un devis solide, fixer un prix qui ne dépend pas du temps de génération, ce que dit un contrat (propriété, responsabilité, confidentialité), et comment parler de l’IA aux clients honnêtement. Repères généraux : le droit dépend de ton pays.
39. Parcours 38 — Claude Code : niveau avancé : Ce parcours rassemble les usages avancés vérifiés : Claude Code en mode non interactif (claude -p) dans des scripts et des pipelines avec sortie structurée ; les plugins pour empaqueter et partager skills, agents, hooks et serveurs MCP ; les worktrees pour paralléliser ; la mémoire automatique et les règles par chemin ; le suivi des coûts. Chaque usage avec ses garde-fous.
40. Parcours 39 — Productivité : Les petites choses qui, répétées cent fois par jour, changent tout : les raccourcis clavier vérifiés, la saisie multiligne, la file d’attente de messages, les questions à côté (/btw), la revue des changements (/diff), les objectifs (/goal) et les boucles (/loop), l’intégration à l’éditeur. Et une journée type qui met tout ça en musique.
41. Parcours 40 — Épreuve finale : Le dernier parcours prépare et encadre l’épreuve : un dépôt d’épreuve généré localement (application d’adhésions avec trois bugs, une clé commitée, des tests cassés, pas de documentation), six épreuves avec preuves, une grille d’évaluation en huit compétences, et les règles d’honnêteté qui font la valeur du résultat. Le résultat est une attestation auto-évaluée (personne ne relit ton travail) ; la page « Épreuve finale » sert de tableau de bord.