De zéro à autonome avec Claude Code.

Tu ne sais pas ce qu'est cd ? Bien. Cette formation part de là et t'amène jusqu'à construire, corriger, tester, versionner et livrer une vraie application avec Claude Code.

41 parcours, 209 leçons, 200 exercices, environ 45 heures. Le parcours 0 est gratuit, sans compte.

Accès Fondateur — 59 € TTC

Paiement unique · Pas d’abonnement

Tous les parcours premium (41 parcours, 92 modules)
209 leçons
200 exercices vérifiés
122 quiz
10 projets présentés comme des missions
Terminal d’entraînement complet
Progression synchronisée sur tous tes appareils
Notes et favoris
Carte des compétences et XP

Débloquer la formation — 59 €

Le programme

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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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é.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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é.
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.
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. »
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.

Voir le programme complet de la formation Claude Code →

Questions fréquentes

Combien de temps faut-il ?

Le contenu représente plusieurs dizaines d’heures (le chiffre exact est calculé depuis les leçons et affiché sur la page d’accueil). À raison d’une heure par jour, les fondations et les premiers pas avec Claude Code prennent deux à trois semaines ; construire et livrer une vraie application, deux à trois mois. Tu avances à ton rythme, la progression est sauvegardée.

Dois-je savoir coder ?

Non. Le parcours 0 part de « je ne sais pas ce qu’est cd ». Tu n’écriras pas beaucoup de code toi-même, mais tu apprendras à le lire, à le vérifier et à le tester : quelqu’un qui accepte du code sans le comprendre finit bloqué au premier bug. Les parcours HTML, CSS, JavaScript et TypeScript donnent juste ce qu’il faut pour collaborer intelligemment avec l’IA.

Windows est-il compatible ?

Oui. Claude Code fonctionne nativement sur Windows 10 et 11 (PowerShell ou CMD, Git pour Windows recommandé), ou dans WSL. Chaque commande de la formation est donnée en version PowerShell quand elle diffère, et le terminal d’entraînement bascule en mode PowerShell si tu choisis Windows.

Et macOS ?

Oui, macOS 13 ou plus récent. C’est l’environnement le plus courant chez les développeurs web : la plupart des exemples bash/zsh s’appliquent tels quels.

Et Linux ?

Oui : Ubuntu 20.04+, Debian 10+, Alpine 3.19+ et les distributions équivalentes. Les exemples macOS s’appliquent presque toujours à Linux (mêmes commandes bash).

Est-ce que Claude fait tout à ma place ?

Il écrit la majorité du code, oui. Mais il ne sait pas ce que tu veux tant que tu ne le dis pas précisément, il se trompe parfois avec assurance, et il ne peut pas vérifier que le résultat correspond aux attentes de ton client. Ton travail : cadrer, vérifier, décider. C’est ce que la formation enseigne.

Que faire quand Claude se trompe ?

D’abord ne pas empiler des correctifs par-dessus une erreur : Échap pour l’interrompre, /rewind ou git restore pour revenir à l’état précédent, puis reformuler la demande avec plus de contexte (le fichier concerné, le message d’erreur complet, le comportement attendu). La règle des deux échecs : si ça rate deux fois, le problème est dans la demande, pas dans l’outil.

Faut-il savoir Git ?

Tu vas l’apprendre ici (parcours 11), et c’est indispensable : un commit avant chaque grosse demande à l’IA est ton bouton « annuler ». Cinq commandes couvrent 90 % des besoins ; la formation ne simplifie pas les commandes dangereuses (reset --hard, push --force) et t’apprend à les reconnaître.

Est-ce que mes fichiers sont envoyés quelque part ?

Quand tu utilises Claude Code, le contenu des fichiers qu’il lit est envoyé aux serveurs d’Anthropic pour être analysé par le modèle : c’est le fonctionnement de l’outil. Rien ne part sans une action de Claude (lecture d’un fichier, résultat d’une commande). Les fichiers de secrets (.env) doivent être exclus par une règle de permission. La formation elle-même n’envoie rien : ta progression reste dans ton navigateur, et le companion local ne parle qu’à ta propre machine.

Quelles permissions donner à Claude Code ?

Pour apprendre : le mode manuel, où chaque modification et chaque commande te sont soumises. Ensuite, élargis progressivement : autorise les commandes que tu comprends (npm test, git status), interdis la lecture des secrets (deny Read(./.env)), et n’utilise jamais --dangerously-skip-permissions sur ta machine de travail. Le parcours 24 détaille tout.

Que se passe-t-il lorsqu’une commande échoue ?

Claude Code lit le message d’erreur et propose une suite ; toi aussi tu dois le lire. La méthode : copier l’erreur entière, identifier qui parle (npm, git, node…), repérer le nom entre guillemets, reproduire, isoler, corriger la cause. Le bouton « Je suis bloqué » de chaque exercice reprend cette méthode pas à pas.

Comment reprendre un projet plus tard ?

Trois choses te sauvent : le CLAUDE.md (l’état du projet, les conventions), l’historique Git (ce qui a été fait, quand, pourquoi) et claude --continue ou /resume pour retrouver une conversation. La formation fait tenir à jour une section « État d’avancement » dans CLAUDE.md précisément pour ça.

Comment mettre à jour les cours si Claude Code évolue ?

Chaque leçon liée à l’outil affiche la version de Claude Code contre laquelle elle a été relue et un statut (vérifié / à relire). Les éléments qui dépendent de la version portent un encadré « Dépend de la version ». La page « Quoi de neuf » liste les changements qui touchent les leçons. Le contenu est structuré (un fichier par parcours, validé automatiquement) pour être révisé rapidement.

Combien coûte Claude Code lui-même ?

Il faut un abonnement Claude (Pro, Max, Team ou Enterprise) ou un compte développeur (Console) facturé à l’usage. Le plan gratuit ne donne pas accès à Claude Code. Ce coût n’est pas inclus dans la formation ; la leçon d’installation t’aide à choisir selon ton usage.

Le companion local est-il obligatoire ?

Non. Chaque exercice a un mode guidé sans companion. Le companion sert à vérifier automatiquement tes vrais fichiers et dépôts Git ; il fonctionne uniquement sur ta machine, avec une liste blanche de vérifications, et ne peut jamais exécuter une commande envoyée par le site.