Tutoriel Claude Code : De zéro à ta première création
La première fois que j'ai lancé Claude Code depuis le terminal, je lui ai donné une seule ligne d'instruction et je l'ai regardé générer un jeu 2D fonctionnel en environ quatre minutes.
Pas une démo jouet. Un shooter top-down jouable — HTML, CSS, JavaScript, boucle de jeu, détection de collisions, le package complet — posé dans mon dossier de projet et tournant dans un navigateur avant même que j'aie fini mon café.
Je code professionnellement depuis des années. Je sais combien de temps il faut pour construire quelque chose qui fonctionne vraiment à partir de zéro. Quatre minutes, ce n'est pas ça. Quatre minutes, c'est autre chose.
Ce qui m'a surpris, ce n'était pas la vitesse — je m'attendais à ce que l'IA soit rapide. Ce qui m'a pris au dépourvu, c'est à quel point le processus était structuré. Claude ne m'a pas juste balancé du code. Il a d'abord planifié, proposé l'architecture, attendu ma confirmation, puis a construit méthodiquement. Le résultat était organisé, lisible et documenté. Pas du code généré à l'arrache qui tourne techniquement mais qui n'a aucun sens structurellement.
Cet écart entre ce que j'attendais et ce que j'ai obtenu est exactement la raison pour laquelle j'ai voulu écrire ce guide. La plupart des tutoriels Claude Code ciblent soit des développeurs qui connaissent déjà l'outil, soit passent trop vite sur les parties qui font vraiment trébucher les gens.
Celui-ci ne fait pas ça. Que tu n'aies jamais ouvert un terminal de ta vie ou que tu sois un développeur qui a entendu parler de Claude Code mais ne s'y est jamais vraiment mis — ce guide couvre ce que tu as vraiment besoin de savoir, dans l'ordre où tu en as vraiment besoin.
Un point que je mentionne maintenant et sur lequel je reviendrai plus tard : il y a une fonctionnalité de mémoire persistante dont presque personne ne parle dans les tutoriels pour débutants, et c'est probablement la chose la plus importante à configurer avant ton premier vrai projet. Garde ça en tête pendant ta lecture.
Ce que Claude Code est vraiment (et ce qu'il n'est pas)
Avant l'installation, le modèle mental compte. Claude Code est souvent décrit comme "un assistant de codage IA" — ce qui est exact mais sous-estime ce qui le rend différent.
La plupart des outils de codage IA sont intégrés dans des éditeurs. Tu écris du code, l'IA suggère des complétions ou répond à des questions dans une barre latérale. Le flux de travail est mené par l'humain ; l'IA assiste. Claude Code inverse ça. Tu décris ce que tu veux construire en langage naturel, et l'IA génère, modifie et gère la base de code. Tu diriges, tu ne tapes pas.
C'est un outil CLI — une interface en ligne de commande — ce qui signifie qu'il tourne dans ton terminal. Pas une application de bureau avec des boutons et des menus. Un prompt terminal où tu tapes des instructions et Claude construit. Le design terminal-first est intentionnel : il garde Claude Code près de là où le code vit réellement et lui donne un accès direct à ton système de fichiers, tes processus en cours et tes commandes shell.
Anthropic a aussi une application de bureau séparée pour Claude — une interface visuelle avec un mode chat, un mode code et une intégration GitHub. Cet outil est excellent pour les débutants qui veulent une rampe d'accès plus douce. Mais c'est dans le CLI que réside la vraie puissance, et ce guide se concentre là-dessus.
Claude Code nécessite un abonnement Claude payant : Pro, Max, Teams ou Enterprise. Tu peux aussi utiliser une clé API avec des crédits. Un point honnête sur le coût : une utilisation intensive brûle les crédits plus vite que tu ne le penserais, surtout sur des projets complexes avec le modèle le plus puissant. Commencer avec un forfait moins cher et passer au supérieur une fois que tu connais tes patterns d'utilisation, c'est la démarche sensée.
Les modèles disponibles — Opus, Sonnet et Haiku — ne sont pas juste des niveaux de qualité. Ce sont des outils différents pour des tâches différentes. Opus pour l'architecture complexe et le raisonnement multi-fichiers, Sonnet pour le travail intermédiaire équilibré, Haiku pour l'itération rapide sur des tâches simples. Tu passes de l'un à l'autre pendant une session avec /model. Comprendre quel modèle utiliser selon la situation, ça se développe avec la pratique, pas en amont.
L'installation : la partie que chaque tutoriel bâcle
L'installation se fait via le terminal. Les utilisateurs Windows doivent ouvrir PowerShell ; les utilisateurs Mac et Linux utilisent Terminal. La commande exacte d'installation diffère selon l'OS et se trouve dans la documentation d'Anthropic — je ne vais pas coller ici une commande qui pourrait être obsolète quand tu liras ceci.
Après l'installation, tu t'authentifies via ton compte Anthropic ou Claude dans le navigateur. Cette partie est simple.
L'étape qui fait trébucher beaucoup de débutants : quand tu navigues pour la première fois vers un dossier de projet, Claude Code te demande de faire confiance à ce répertoire. C'est une vérification de sécurité — tu indiques explicitement à Claude Code qu'il a la permission de lire et modifier les fichiers à cet endroit. Ne passe pas cette étape à la légère. Comprends dans quel dossier tu te trouves et ce à quoi tu donnes accès.
Maintenant — avant de faire quoi que ce soit d'autre — installe Git.
Je dis ça avec insistance parce que c'est l'étape d'installation la plus déterminante et celle que la plupart des tutoriels traitent comme optionnelle. Elle ne l'est pas. Travailler avec du code généré par IA sans contrôle de version est un genre de souffrance bien particulier : l'IA produit quelque chose qui marche, tu itères dessus, quelque chose casse, et tu n'as aucun moyen de revenir à l'état fonctionnel.
Git est le système de points de sauvegarde. Chaque fois que tu atteins un état qui te satisfait, tu fais un commit. Si quelque chose casse — hallucination de l'IA, mauvaise instruction, cas limite inattendu — tu reviens en arrière. Claude Code peut t'aider à installer Git si tu n'es pas familier avec le terminal, y compris pour gérer les demandes de privilèges administrateur qui apparaissent sous Windows.
Une fois Git installé localement, connecte-le à un compte GitHub gratuit avec gh auth login. Claude peut exécuter cette commande pour toi. Ce que tu obtiens : ton code sauvegardé à distance, un historique de chaque état fonctionnel, et la possibilité de partager ou collaborer si tu le souhaites. Cette configuration prend peut-être quinze minutes et t'épargne des heures de galère plus tard.
Associer Claude Code à un éditeur de code complète l'installation. VS Code et Cursor fonctionnent tous les deux très bien. Le flux de travail est le suivant : ouvre ton dossier de projet dans l'éditeur, utilise le terminal intégré de l'éditeur pour lancer Claude Code, et regarde l'explorateur de fichiers se mettre à jour en temps réel pendant que Claude génère et modifie des fichiers. La couche visuelle rend le processus nettement plus lisible qu'un terminal brut, surtout quand tu gères des projets multi-fichiers.
Un conseil pratique sur l'association avec l'éditeur : garde l'explorateur de fichiers et le terminal côte à côte. Quand Claude génère un nouveau fichier, clique dessus immédiatement et parcours-le avant l'instruction suivante. Tu ne révises pas chaque ligne — tu construis une carte mentale de ce qui existe pour que tes instructions suivantes soient précises. Dire à Claude de "mettre à jour le composant header" quand le fichier s'appelle en fait navbar.jsx gaspille un aller-retour. Connaître la structure de tes fichiers signifie que tes prompts tombent juste du premier coup.
Cursor a un léger avantage sur VS Code ici parce que sa propre intégration IA fonctionne naturellement aux côtés de Claude Code sans que les deux se gênent mutuellement. Tu peux utiliser les suggestions inline de Cursor pour les petites modifications tout en utilisant Claude Code pour tout ce qui implique plusieurs fichiers ou un raisonnement à l'échelle du projet. Les outils se complètent plutôt qu'ils ne se font concurrence.
Les trois modes qui changent ta façon de travailler
Claude Code a trois modes de fonctionnement, chacun utile dans des situations différentes. Passer de l'un à l'autre se fait avec un simple Shift + Tab.
Le mode Ask est le mode par défaut. Claude te demande confirmation avant d'exécuter toute commande ou d'écrire tout fichier. Chaque action nécessite ton approbation explicite. C'est le bon mode pour le terrain inconnu — quand tu travailles dans une base de code que tu n'as pas construite, sur une tâche avec un risque élevé de casser quelque chose, ou chaque fois que tu veux une visibilité totale avant que Claude agisse.
Le mode Auto-accept (parfois appelé mode coding) supprime l'étape de confirmation. Claude exécute les modifications et lance les commandes automatiquement. L'avantage en termes de vitesse est réel : les tâches nécessitant des dizaines de petites modifications de fichiers avancent nettement plus vite sans les demandes constantes d'approbation. Utilise-le pour les projets que tu comprends bien et que tu fais confiance à Claude pour gérer, pas pour tes premières sessions avec une base de code inconnue.
Le mode Planning est celui que la plupart des débutants sautent et que la plupart des utilisateurs avancés ne jurent que par lui. Avant d'écrire une seule ligne de code, Claude génère un plan détaillé — l'approche architecturale, la structure des fichiers, l'ordre d'implémentation, les cas limites qu'il anticipe. Tu révises le plan, tu le modifies si nécessaire, puis tu confirmes. Claude construit selon le plan.
La différence de qualité entre foncer directement dans le code et lancer le mode planning d'abord n'est pas subtile. L'approche planifiée produit du code qui tient ensemble comme un système. L'approche directe produit du code qui marche pour la tâche décrite et qui nécessite souvent une restructuration dès que tu demandes quoi que ce soit d'adjacent à la requête originale.
Pour tout projet plus grand qu'un seul fichier, commence en mode planning. Les quelques minutes nécessaires pour générer et réviser un plan sont immédiatement rentabilisées.
Ton premier vrai projet : comment le flux de travail se déroule concrètement
Voici à quoi ressemble une vraie session de projet du début à la fin.
Ouvre ton terminal (ou le terminal intégré de ton éditeur), navigue vers le dossier où tu veux que le projet vive, et lance Claude Code. Fais confiance au répertoire quand on te le demande.
Passe en mode planning avec Shift + Tab. Décris ton projet en langage naturel — sois précis sur ce que tu veux. "Construis un jeu de tir top-down 2D" te donne quelque chose. "Construis un jeu de tir top-down 2D en JavaScript vanilla avec des contrôles clavier, un système de vie pour le joueur, des ennemis qui réapparaissent après avoir été détruits, et un compteur de score affiché dans le coin supérieur droit" te donne quelque chose de nettement meilleur. La précision est une compétence en développement assisté par IA, et elle se compose rapidement.
Claude génère un plan. Lis-le. Lis-le vraiment — ne te contente pas de défiler jusqu'en bas et de confirmer. Le plan te dit quelles hypothèses Claude fait. Si tu vois quelque chose qui ne correspond pas à ton intention, corrige-le avant que la construction commence. Changer de direction pendant un plan te coûte trente secondes. Changer de direction après la génération de vingt fichiers te coûte beaucoup plus.
Confirme le plan. Regarde Claude construire.
Le projet inclura un dossier .claw que Claude utilise pour le suivi interne. Tu n'as pas besoin de le gérer manuellement. Tes fichiers de projet réels apparaissent à côté. Quand la construction est terminée, teste le résultat — dans le cas d'un projet web, ouvre le HTML généré dans un navigateur et interagis avec. Les vrais tests font remonter de vrais problèmes qu'aucune quantité de revue de code ne trouve.
Itère à partir de là. "Le respawn des ennemis est trop rapide, ajoute un délai de trois secondes" est une instruction valide. "La police du compteur de score devrait correspondre à l'esthétique générale du jeu" est une instruction valide. L'affinage en langage naturel fonctionne tout au long de la session — tu n'as pas besoin de passer en mode développeur pour faire des ajustements.
Après une itération significative — quelque chose fonctionne comme tu le veux, une fonctionnalité est complète, un bug est corrigé — fais un commit Git. Ça prend dix secondes. git add . puis git commit -m "player health system working". Claude Code peut s'en charger pour toi si tu préfères ne pas taper les commandes manuellement : demande-lui simplement de commiter l'état actuel avec un message descriptif et il le fera. La discipline de commiter aux points stables est ce qui sépare le développement assisté par IA productif des sessions qui finissent par "je dois tout recommencer parce que je n'arrive pas à revenir au moment où ça marchait."
Deux raccourcis à connaître immédiatement : Alt + Enter (Windows) ou Option + Enter (Mac) insère un saut de ligne dans ton prompt sans le soumettre. Indispensable pour les instructions en plusieurs paragraphes. Esc Esc (deux appuis rapides) efface le prompt en cours si tu veux recommencer ton instruction. Et @ suivi d'un nom de fichier te permet de référencer un fichier spécifique dans ton instruction — "mets à jour la logique dans @game.js pour augmenter la vitesse des ennemis de 20% après chaque vague" est plus précis que "mets à jour la logique du jeu", et la précision est ce qui maintient les sessions sur la bonne voie.
Les fonctionnalités qui ont changé ma façon de travailler
La mémoire persistante avec CLAUDE.md.
Les sessions ne conservent pas un contexte illimité. Quand tu fermes Claude Code et le rouvres le lendemain, il repart à zéro. Pour un court script, ça va. Pour un projet que tu construis sur des jours ou des semaines, c'est un vrai problème — chaque session nécessite de réexpliquer ce qu'est le projet, quelles conventions tu utilises, quelles décisions tu as déjà prises.
CLAUDE.md résout ça. Créé avec la commande /init (parfois affiché comme /nit dans la documentation), c'est un fichier markdown qui vit à la racine de ton projet et stocke tout ce dont Claude a besoin pour maintenir la continuité : aperçu du projet, design patterns, conventions de nommage, décisions architecturales, contraintes, et toute préférence sur la façon dont Claude devrait se comporter dans cette base de code spécifique.
À chaque nouvelle session, Claude lit CLAUDE.md en premier. Il reprend là où tu t'es arrêté sans que tu aies à le rebriefter.
Investis du temps pour écrire un bon CLAUDE.md au début de tout projet multi-sessions. Mets-le à jour quand tu prends des décisions significatives en cours de projet. Considère-le comme le brief de projet que tu écrirais pour un nouveau membre de l'équipe — suffisamment complet pour que quelqu'un sans contexte préalable puisse comprendre le système.
Sélection du modèle en cours de session.
La commande /model te permet de passer entre Opus, Sonnet et Haiku à tout moment. Utilisation pratique : commence la planification et le travail d'architecture en Opus où la qualité de raisonnement compte le plus, passe à Sonnet ou Haiku pour les étapes d'implémentation mécaniques où tu ne fais que générer du boilerplate ou effectuer de petits changements répétitifs. Cette approche gère les coûts sans sacrifier la qualité là où la qualité compte.
Les tâches en arrière-plan.
Certaines commandes bloquent le terminal — lancer un serveur de développement local, surveiller les changements de fichiers, traiter une longue opération. Claude Code te permet de les pousser en arrière-plan pour que tu puisses continuer à donner des instructions pendant qu'elles tournent. Ctrl + T liste les tâches en arrière-plan actives ; K arrête une tâche sélectionnée. Ça maintient ton flux de travail ininterrompu plutôt que de te forcer à ouvrir une seconde fenêtre de terminal pour tout ce qui tourne en continu.
Agents et skills.
Les agents sont des processus parallèles spécialisés qui gèrent des parties distinctes d'un projet simultanément. Un agent gère le style frontend pendant qu'un autre s'occupe de la logique backend, les deux tournant en parallèle et rendant compte à la session principale. L'intégration du serveur MCP étend ça encore plus loin — les agents peuvent se connecter à Notion, Gmail, Google Drive et d'autres services externes, récupérant du contexte réel depuis ton environnement de travail.
Les skills sont des flux de travail reproductibles que tu entraînes Claude à exécuter de manière cohérente. Si tu exécutes la même séquence de déploiement, la même routine de tests ou le même flux de génération de contenu de manière répétée, un skill encapsule ça dans une commande réutilisable. Avec le temps, ta bibliothèque de skills devient un système d'automatisation personnel construit autour de ta façon réelle de travailler.
Ce à quoi t'attendre vs. ce que les démos montrent
Évaluation honnête, parce que c'est important avant que tu investisses du temps dans cette configuration.
Claude Code est véritablement impressionnant pour des tâches bien définies avec des entrées claires. Génération de jeux, scaffolding d'API, scripts utilitaires, génération de documentation, traitement de données structurées — ces catégories produisent systématiquement d'excellents premiers jets. La sortie du mode planning est cohérente et l'implémentation la suit.
Là où ça se complique : les grandes bases de code existantes qui n'ont pas été écrites avec l'assistance IA en tête. Envoyer Claude Code dans un projet legacy complexe et lui demander de refactoriser ou d'étendre des fonctionnalités nécessite une construction de prompts plus soignée et une supervision plus active que de construire quelque chose de zéro. La fenêtre de contexte du modèle a ses limites, et les systèmes multi-fichiers complexes avec des interdépendances profondes peuvent dépasser ce qu'il retient proprement.
Les instructions doivent être précises. "Améliore ça" n'est pas une instruction utile. "Le layout mobile casse à 375px — la navigation chevauche la section hero, corrige le z-index et ajuste les règles flex-wrap" est une instruction utile. La qualité de ce que tu obtiens en sortie est directement proportionnelle à la précision de ce que tu fournis en entrée. C'est une compétence qui demande une pratique délibérée, et les premières sessions produisent souvent des résultats médiocres non pas parce que l'outil est faible mais parce que les prompts sont vagues.
La consommation de crédits lors des sessions intensives s'accumule. La génération complexe multi-fichiers sur Opus peut brûler des crédits significatifs en un seul après-midi. Si tu expérimentes sans objectif de projet clair, fais-le sur Haiku. Réserve Opus pour le travail qui en a vraiment besoin.
Et révise toujours le code généré par l'IA avant de l'exécuter dans un environnement qui compte. Non pas parce que Claude Code n'est pas fiable — la qualité de la sortie est élevée — mais parce que le code généré par IA peut contenir des cas limites, des considérations de sécurité ou des hypothèses sur ton environnement qu'il ne pouvait pas connaître sans qu'on le lui dise explicitement. La revue est une habitude professionnelle, pas un signe que l'outil a échoué.
Construire le bon modèle mental
Les développeurs qui tirent le meilleur parti de Claude Code partagent un trait commun : ils ont arrêté de le considérer comme de l'autocomplétion et ont commencé à le voir comme de la direction.
Un bon réalisateur n'écrit pas chaque réplique. Un bon réalisateur a une vision claire, la communique précisément, donne des retours sur ce qui ne fonctionne pas, et façonne la performance vers quelque chose qu'il n'aurait pas pu produire seul. C'est la compétence à développer avec Claude Code — pas la capacité à prompter de manière astucieuse, mais la capacité à tenir une vision claire de ce que tu construis, la communiquer précisément, et itérer vers elle efficacement.
Les débutants qui se frustrent avec l'outil essaient généralement de lui faire lire dans leurs pensées. "Construis-moi quelque chose de cool" produit quelque chose de générique. "Construis un outil de suivi des finances personnelles avec des résumés de dépenses hebdomadaires affichés sous forme de graphiques en barres, un système simple de tags par catégorie, et un export CSV — pas de login requis, stockage local uniquement" produit quelque chose que tu peux réellement utiliser.
La configuration que j'ai décrite dans ce guide — intégration Git, CLAUDE.md pour la mémoire persistante, mode planning avant chaque projet substantiel, sélection du modèle adaptée à la complexité de la tâche — crée les conditions pour que l'outil performe bien. Ce ne sont pas des bonnes pratiques optionnelles. C'est le socle qui fait fonctionner tout le reste.
Un truc qui vaut la peine d'être commencé dès aujourd'hui : crée un dossier de projet test, installe Claude Code, configure Git, et construis quelque chose de petit avec le mode planning activé. Une appli de to-do, une calculatrice basique, une landing page statique. Pas parce que le résultat sera utile — il ne le sera pas, c'est un projet test — mais parce que la mémoire musculaire du flux de travail est le vrai produit de cette première session. Tout ce qui suit ira plus vite.
Les développeurs qui seront les plus efficaces avec les outils IA dans les prochaines années ne sont pas nécessairement les meilleurs programmeurs. Ce sont les personnes qui ont appris tôt à bien diriger.
Travaillons ensemble
Tu cherches à construire des systèmes IA, automatiser des flux de travail ou scaler ton infrastructure tech ? Je serais ravi de t'aider.
- Fiverr (builds personnalisés et intégrations) : fiverr.com/s/EgxYmWD
- Portfolio : mejba.me
- Ramlit Limited (solutions enterprise) : ramlit.com
- ColorPark (design et branding) : colorpark.io
- xCyberSecurity (services de sécurité) : xcybersecurity.io
