Tu viens d'installer Claude Code et personne t'a vraiment expliqué

Cette page n'est pas un cours d'IA. Elle est écrite pour la version de toi qui a installé Claude Code la semaine dernière et qui se demande pourquoi son collègue parle d'agents alors que franchement, c'est juste un ChatGPT qui modifie le code, non ?

On va répondre exactement à ces questions, dans cet ordre :

1. C'est quoi concrètement ?
2. Si tu viens de Copilot, ce qui change.
3. Tes 5 premiers prompts (pas des commandes magiques).
4. 3 réflexes qui changent tout.
5. 4 erreurs classiques à éviter.
6. Le jargon décrypté (rapide, sans examen).
7. Quand t'auras envie d'aller plus loin.

Pas de jargon non-expliqué. Quand un mot technique apparaît pour la première fois, il est défini juste après. Le reste c'est ton terminal et toi.

Claude Code, c'est un programme qui tourne dans ton terminal. Tu lui parles en français (ou en anglais), il modifie tes fichiers, lance des commandes, lit ton code, écrit des tests. Pas de copier-coller depuis un chat web.

L'analogie qui marche le mieux :

Imagine ChatGPT, mais qui a accès à ton terminal et tes fichiers. Quand tu dis « ajoute un bouton qui fait X », il modifie le bon fichier directement. Si tu dis « les tests plantent », il les lance, lit l'erreur, et propose un fix.

C'est tout. La complexité que tu entends en daily (agents, skills, hooks…) c'est juste les noms de ce qu'il fait sous le capot. T'as pas besoin de les connaître pour t'en servir.

Pas de critique de Copilot ici, juste un repère pour celui qui connaît. Les deux outils s'utilisent autrement.

En pratique : si t'aimes écrire du code et que l'outil complète, Copilot reste très bien. Si t'aimes décrire ce que tu veux et que l'outil fasse les modifs, Claude Code te plaira sûrement plus.

Le piège classique du débutant : balancer une grosse demande type « écris-moi un système d'authentification complet ». Ça marche jamais bien. Comme avec un humain, vaut mieux commencer doux.

Lis le fichier src/auth/login.ts et explique-moi en 5 lignes ce qu'il fait.

Trouve où on appelle la fonction logUserAction et liste tous les call sites.

Dans src/components/Button.tsx, ajoute un prop "loading" qui affiche un spinner et désactive le bouton. Garde le même style que les autres props.

Lance "npm test", regarde l'erreur, et propose un fix. Ne modifie rien sans me demander.

Refactor src/utils/format.ts pour extraire les fonctions liées aux dates dans un nouveau fichier src/utils/dates.ts. Update tous les imports. Lance les tests à la fin.

1. Avant de modifier, fais lire.

   « Lis X, dis-moi ce que ça fait, puis attendons » avant « modifie X ». Tu vérifies qu'il a compris, il enrichit son contexte, ses modifs sont meilleures derrière.

2. Crée un CLAUDE.md à la racine.

   Mets dedans : nom du projet, stack technique, conventions (« on commit en français », « tests toujours en __tests__/ », « ne jamais toucher migrations/ sans demander »). Il le lit à chaque session. Plus tu le soignes, plus il gagne en autonomie.

3. Lis ce qu'il propose avant de valider.

   En mode interactif, il te demande l'autorisation pour chaque commande risquée. Ne tape pas « yes » en pilote automatique. Lis le diff. Tu progresses comme ça.

• ❌ « J'accepte tout sans lire »

  La première fois qu'il fait un rm -rf sur un dossier que tu pensais vide, tu te souviens de ce conseil. Ralentis. Lis le diff.

• ❌ « Je crois qu'il connaît mon repo »

  Au début d'une session, il connaît : ton CLAUDE.md, le nom de ton dossier, et c'est tout. Pour le reste il faut qu'il aille lire. Donne-lui les noms de fichiers pertinents quand tu les connais — ça lui économise du tâtonnement.

• ❌ « Je lui demande tout d'un coup »

  « Refactor toute l'app + ajoute un système d'auth + écris les tests + déploie » → résultats incertains. Découpe. Une chose à la fois. Tu vas vite, mais tu vas droit.

• ❌ « Je prends pas le temps de comprendre ce qu'il fait »

  Si tu valides sans regarder, tu deviens dépendant sans apprendre. Si tu prends 30 secondes pour comprendre ce qu'il a touché et pourquoi, tu progresses comme dev en même temps. C'est l'objectif initial.

Tu peux ignorer cette section au début et y revenir quand un mot tombe en daily. Mais voilà l'essentiel, pour ne plus avoir le sentiment de « travailler avec des chinois ».

LLM

Large Language Model. Le cerveau. Claude, GPT, Gemini sont des LLM. Claude Code utilise Claude (le LLM d'Anthropic).

Tool / outil

Une action que le LLM peut décider de faire. Lire un fichier, lancer une commande shell, modifier du texte. Quand tu vois « il a appelé le tool Bash », c'est juste qu'il a lancé une commande.

Agent

Le LLM qui tourne en boucle : il regarde où il en est, décide d'utiliser un tool, voit le résultat, recommence jusqu'à finir la tâche. Claude Code est un agent. Le mot n'a rien de magique.

Sub-agent

Un agent qui tourne dans une « bulle » à part avec sa propre conversation. Utile pour explorer un truc sans polluer ta conversation principale.

Skill

Une recette pré-écrite pour une tâche récurrente. Genre /sparc ou /save. Tu tapes un slash + le nom et il suit la recette.

Hook

Un script qui se déclenche automatiquement avant ou après certaines actions. Genre « avant chaque git push, lance les tests ». Tu n'en as vraiment pas besoin pour démarrer.

MCP

Model Context Protocol. La norme qui permet de brancher des outils externes (un Notion, une base de données, GitHub) à un LLM. Pareil : tu n'en as pas besoin tant que tu codes en local.

Plugin

Un bundle de skills + agents + hooks + MCP packagés ensemble. Tu installes un plugin, tu obtiens d'un coup un ensemble de capacités. Genre un thème pour ton éditeur, mais pour Claude Code.

Tu vois ? C'est juste du vocabulaire. Aucun de ces concepts n'est nécessaire pour faire ton premier vrai prompt. Tu peux utiliser Claude Code pendant des mois sans jamais écrire un skill ni configurer un hook.

Question légitime de débutant : quand tu lances Claude Code, qu'est-ce qui s'exécute sur ta machine et qu'est-ce qui passe par les serveurs d'Anthropic ?

Concrètement, à chaque tour : ton prompt + le contexte accumulé (résumé de ce qui s'est passé, fichiers lus, sorties de commandes) part à l'API Anthropic. Le modèle renvoie soit du texte, soit la décision « j'appelle l'outil X avec ces paramètres ». Le harness local exécute l'outil sur ta machine, renvoie le résultat au modèle, et ainsi de suite. C'est cette boucle qu'on appelle agentic loop.

Tu reviens ici dans 2-3 semaines, après tes 10-20 premières sessions. À ce moment-là, tu commenceras à avoir des questions plus pointues : « pourquoi il a relu ce fichier 3 fois ? », « comment il décide quoi explorer ? », « est-ce que je peux écrire mon propre skill ? ». Ces réponses sont sur les autres pages :

• → Théorie

  Architecture, context window, hooks, skills, MCP, agents SDK. Quand t'es prêt à comprendre comment ça marche.

• → Écosystème

  Plugins, MCP servers, skills officiels d'Anthropic, SDKs (Python, TypeScript, Go). Quand tu veux installer ou builder des trucs en plus.

• → Case studies

  6 sites perso construits en pair-programming, 0 ligne de code écrite par l'humain. Plus une section Tools tested où on documente nos expériences (RTK adopté, Ruflo testé puis rejeté avec 8 leçons à reprendre).

• → Learning

  Preview live des dernières news agrégées depuis 3 flux RSS (Simon Willison, Anthropic, Human Coders FR filtré sur Claude/MCP), plus le catalogue curé des blogs/podcasts à suivre. Mis à jour chaque lundi.

• → Vidéos

  Chaînes YouTube spécifiques Claude Code, EN et FR. Pas d'AI-influencer générique — celles qu'on regarde vraiment pour progresser.

• → À propos

  Pourquoi ce site existe, la stack technique, les sources, et les crédits IA (Claude Code pour le code, openart.ai pour le visuel).