Ce que tu utilises aujourd'hui

Quand tu utilises ChatGPT ou Claude dans ton navigateur, voici ce qui se passe : tu écris un message, l'IA te répond avec du texte, et ensuite c'est à toi de faire quelque chose avec cette réponse. Tu copies le code qu'elle a écrit, tu le colles dans un fichier. Tu prends sa suggestion d'email, tu la copies dans Gmail. Tu lis son analyse de ton spreadsheet, et tu appliques les modifications à la main.

C'est comme appeler un expert au téléphone. Il te donne d'excellents conseils. Mais il ne peut rien faire pour toi directement. Il ne voit pas ton écran, il n'a pas accès à tes fichiers, il ne peut pas appuyer sur les boutons à ta place. Toute l'exécution repose sur toi.

C'est frustrant pour une raison précise : 80% du temps que tu passes avec l'IA n'est pas sur la réflexion. C'est sur le transfert — copier, coller, reformater, adapter, vérifier que rien ne s'est perdu dans la traduction entre ce que l'IA a dit et ce que tu as fait.

Ce que le CLI change

Un agent CLI (Command Line Interface), c'est le même cerveau que celui du chat, mais avec les mains. Il est installé sur ton ordinateur. Il a accès à ton système de fichiers — tes dossiers, tes documents, ton code. Il peut créer des fichiers, les modifier, les supprimer. Il peut exécuter des commandes. Il peut lancer des programmes. Et avec les bonnes connexions (on verra ça dans le module MCPs), il peut aussi toucher à tes emails, ton calendrier, tes spreadsheets.

La différence est fondamentale. Ce n'est plus "donne-moi des conseils que j'exécuterai moi-même." C'est "fais-le."

Pour rendre ça concret : imaginons que tu veuilles créer un script qui lit une Google Sheet de contacts, filtre ceux qui n'ont pas été contactés depuis 30 jours, et t'envoie un email de rappel avec la liste.

Pourquoi trois agents et pas un seul

Tu vas installer trois agents CLI : Claude Code (Anthropic), Gemini CLI (Google), et Codex (OpenAI). C'est comme avoir trois consultants avec des profils différents.

Claude Code est le plus complet pour du travail de fond. Son raisonnement est le plus abouti, sa capacité à comprendre un projet dans sa globalité est la meilleure du marché. C'est ton architecte principal. Par contre, il nécessite un abonnement payant ($20/mois minimum). Claude Code offre aussi 1 million de tokens de fenêtre de contexte.

Gemini CLI est celui de Google. Son avantage : il est gratuit (un généreux quota gratuit, environ 1000 requêtes/jour avec un compte Google). Sa fenêtre de contexte est gigantesque (1 million de tokens). C'est ton analyste, ton éclaireur — idéal pour explorer un codebase inconnu ou faire du brouillon rapide.

Codex est celui d'OpenAI. Construit en Rust (un langage qui produit des programmes très rapides), avec un système de sandbox qui isole ses actions pour plus de sécurité. Il est inclus dans l'abonnement ChatGPT Plus ($20/mois). Son modèle spécialisé pour le code est optimisé pour les tâches de développement.

L'idée n'est pas d'utiliser les trois en permanence. C'est de les avoir tous les trois pour pouvoir choisir le bon outil selon la situation. Et aussi, honnêtement, pour pouvoir comparer. L'IA évolue tellement vite que l'agent qui est le meilleur aujourd'hui ne sera peut-être pas le meilleur dans trois mois. En les ayant tous, tu restes flexible.

Ce que tu auras à la fin de ce programme

• Un terminal configuré et agréable à utiliser (Ghostty)
• Trois agents AI installés et authentifiés
• Des connexions à tes outils quotidiens (Google Workspace, GitHub)
• Des "skills" qui spécialisent tes agents pour ton activité
• Un vrai outil fonctionnel, construit de A à Z avec tes agents

Pourquoi un bon terminal compte

Tu vas passer beaucoup de temps dans ton terminal. C'est là que tes agents IA vivent, c'est là que tu tapes tes commandes, c'est là que tu vois les résultats. Avoir un terminal rapide, lisible et agréable, c'est pas du luxe — c'est de la productivité.

La police de code

Les polices de code (monospace) sont conçues pour que chaque caractère ait la même largeur. C'est ce qui rend le code lisible — les colonnes s'alignent, les indentations sont nettes. On va installer JetBrains Mono, la police la plus populaire chez les développeurs. Elle a des ligatures (les combinaisons comme => ou != deviennent des symboles plus lisibles).

Ton thème, ton choix

Un thème, c'est le jeu de couleurs de ton terminal — le fond, le texte, les accents. Il y en a des centaines. Certains préfèrent un fond très sombre, d'autres un fond plus doux. Certains aiment les couleurs vives, d'autres les tons pastel. On va te montrer comment explorer les thèmes et choisir celui qui te plaît.

Qu'est-ce qu'un terminal, vraiment ?

Ton ordinateur a deux couches d'interaction. La couche que tu connais, c'est l'interface graphique — les fenêtres, les icônes, la souris, le clic. Cette couche a été inventée par Xerox dans les années 70, popularisée par Apple avec le Macintosh en 1984, et c'est devenu la norme. Elle est intuitive. Tu vois un fichier, tu double-cliques dessus, il s'ouvre.

Mais sous cette couche graphique, il y a une couche plus ancienne et plus puissante : la ligne de commande. C'est la façon originale de parler à un ordinateur. Pas d'icônes, pas de souris. Tu tapes des instructions en texte, l'ordinateur les exécute et te répond en texte.

Le terminal, c'est le programme qui te donne accès à cette couche. C'est une fenêtre dans laquelle tu tapes des commandes.

Pourquoi la ligne de commande est plus puissante

Ce n'est pas un retour en arrière. L'interface graphique est excellente pour découvrir et explorer — tu vois ce qui est disponible, tu cliques dessus. Mais elle a un défaut fondamental : elle est faite pour les humains. Chaque action nécessite un clic, un déplacement de souris, une interaction physique.

La ligne de commande, elle, est faite pour être automatisée. Et c'est exactement ce dont tu as besoin quand tu travailles avec des agents AI.

Quand tu dis à Claude Code "renomme tous les fichiers de ce dossier pour qu'ils commencent par la date", Claude Code n'a pas besoin de fenêtres, de souris, ou d'icônes. Il a besoin de taper une commande. Le terminal est son interface naturelle.

Autre avantage : la composabilité. Dans une interface graphique, chaque programme est un îlot. Word ne sait pas parler à Excel, qui ne sait pas parler à ton navigateur. Dans le terminal, tout est texte, et les outils sont conçus pour se passer des données les uns aux autres. Cette philosophie Unix ("faire une seule chose et la faire bien, puis combiner") a 50 ans et elle est au cœur de la raison pour laquelle les développeurs travaillent en terminal.

Terminal, shell, console — c'est quoi la différence ?

Tu vas rencontrer ces trois mots. Ils sont liés mais distincts.

Le terminal (ou "émulateur de terminal"), c'est la fenêtre. C'est le programme que tu ouvres. Terminal.app sur Mac, Windows Terminal sur Windows, et Ghostty, que tu viens d'installer. Son rôle est d'afficher du texte et de capturer ce que tu tapes au clavier. Rien de plus.

Le shell, c'est le programme qui tourne à l'intérieur du terminal et qui interprète tes commandes. Quand tu tapes ls, c'est le shell qui comprend que tu veux lister les fichiers, qui va les chercher, et qui affiche le résultat. Sur Mac, le shell par défaut est zsh (Z Shell). Sur la plupart des Linux, c'est bash (Bourne Again Shell). Sur Windows, le shell par défaut dans Windows Terminal est PowerShell. Ce sont des programmes différents avec des syntaxes légèrement différentes, mais pour ce que tu vas faire, ça ne change quasiment rien.

La console, c'est un terme hérité de l'époque des gros ordinateurs, quand le "terminal" était un vrai meuble physique. Aujourd'hui, c'est souvent utilisé comme synonyme de terminal. Ne te prends pas la tête avec ça.

Comment fonctionne une commande

Quand tu tapes quelque chose dans le terminal et que tu appuies sur Entrée, voici ce qui se passe en coulisses :

• Le shell lit ce que tu as tapé
• Il découpe ta commande en morceaux : le nom du programme + les arguments
• Il cherche le programme sur ton ordinateur (dans des dossiers prédéfinis appelés le PATH)
• Il lance le programme avec les arguments que tu as donnés
• Le programme fait son travail et envoie le résultat en texte
• Le shell affiche ce texte dans le terminal

Exemple : quand tu tapes ls -la Documents, le shell comprend :

• Programme : ls (lister des fichiers)
• Argument -la : afficher en mode détaillé (l) y compris les fichiers cachés (a)
• Argument Documents : dans quel dossier regarder

Cette mécanique est identique pour toutes les commandes. Un programme, des options, des arguments. C'est tout.

Les commandes essentielles

Tu n'as pas besoin de connaître des centaines de commandes. Avec les 10 suivantes, tu peux faire 95% de ce dont tu auras besoin. Apprends-les comme tu apprends des mots dans une nouvelle langue — chacune fait une seule chose, et elle la fait bien.

Naviguer

pwd — Print Working Directory. Affiche le chemin complet du dossier dans lequel tu te trouves actuellement. C'est ta boussole. Si tu es perdu, tape pwd et tu sauras exactement où tu es.

cd — Change Directory. C'est comme marcher d'une pièce à l'autre dans une maison. cd Documents te fait entrer dans le dossier Documents. cd .. te fait remonter d'un niveau (le dossier parent). cd ~ te ramène directement chez toi (ton dossier personnel). Et cd tout court (sans argument) fait la même chose que cd ~.

/Users/toi

/Users/toi/Documents

/Users/toi

Regarder

ls — List. Affiche le contenu d'un dossier. ls tout court montre le dossier actuel. ls -l montre les détails (taille, date, permissions). ls -a montre aussi les fichiers cachés (ceux qui commencent par un point, comme .gitignore). ls -la combine les deux. Tu l'utiliseras tout le temps.

cat — Affiche le contenu d'un fichier en entier. cat README.md te montre ce qu'il y a dans le fichier. Pour les fichiers longs, préfère head (les 10 premières lignes) ou tail (les 10 dernières).

Créer et supprimer

mkdir — Make Directory. Crée un nouveau dossier. mkdir mon-projet crée un dossier appelé "mon-projet". Le flag -p permet de créer des dossiers imbriqués d'un coup : mkdir -p projets/site/assets crée les trois niveaux.

touch — Crée un fichier vide. touch notes.txt crée un fichier vide appelé "notes.txt". Si le fichier existe déjà, ça ne fait que mettre à jour sa date de modification.

rm — Remove. Supprime un fichier. rm notes.txt supprime le fichier. Attention : il n'y a pas de corbeille dans le terminal. Un fichier supprimé avec rm est parti pour de bon. Pour supprimer un dossier et tout son contenu : rm -rf mon-dossier. Le -r signifie "récursivement" (tout ce qui est dedans) et le -f signifie "sans demander confirmation".

Déplacer et copier

mv — Move. Déplace un fichier d'un endroit à un autre. mv photo.jpg Images/ déplace le fichier dans le dossier Images. C'est aussi la commande pour renommer un fichier : mv ancien-nom.txt nouveau-nom.txt.

cp — Copy. Copie un fichier. cp original.txt copie.txt crée une copie. Pour copier un dossier entier : cp -r mon-dossier/ copie-dossier/.

Écrire dans un fichier

echo — Affiche du texte. Mais combiné avec > ou >>, ça écrit dans un fichier. echo "Bonjour" > fichier.txt crée le fichier avec "Bonjour" dedans (écrase si le fichier existe). echo "Monde" >> fichier.txt ajoute "Monde" à la fin sans écraser.

Première ligne
Deuxième ligne

Chercher

grep — Cherche du texte dans des fichiers. grep "erreur" logs.txt affiche toutes les lignes qui contiennent "erreur". C'est un outil puissant pour trouver des informations dans des fichiers. Tu verras tes agents IA l'utiliser constamment.

clear — Nettoie l'écran du terminal. Ça ne supprime rien — ça scroll juste vers le haut pour avoir un écran propre. Le raccourci clavier Cmd + K (Mac) ou Ctrl + L (Linux/Windows) fait la même chose.

Le système de fichiers vu depuis le terminal

/
├── Users/          ← les dossiers de chaque utilisateur
│   └── toi/        ← ton dossier personnel (aussi appelé ~)
│       ├── Desktop/
│       ├── Documents/
│       ├── Downloads/
│       └── ...
├── Applications/   ← les programmes installés
├── Library/        ← fichiers système et configurations
└── ...

C:\
├── Users\          ← les dossiers de chaque utilisateur
│   └── toi\        ← ton dossier personnel
│       ├── Desktop\
│       ├── Documents\
│       ├── Downloads\
│       └── ...
├── Program Files\  ← les programmes installés (64-bit)
├── Windows\        ← fichiers système
└── ...

Le PATH : comment ton ordinateur trouve les programmes

Quand tu tapes git ou node ou claude, le shell doit savoir où trouver ces programmes. Il ne va pas chercher dans tout ton disque dur à chaque fois — ce serait beaucoup trop lent.

Il a une liste de dossiers dans lesquels chercher. Cette liste s'appelle le PATH. C'est une variable d'environnement (un réglage de ton shell) qui contient une suite de dossiers séparés par : (sur Mac/Linux) ou ; (sur Windows).

/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin

Ça veut dire : "quand je tape le nom d'un programme, cherche-le d'abord dans /usr/local/bin, puis dans /usr/bin, puis dans /bin, puis dans /opt/homebrew/bin."

Qu'est-ce que Node.js ?

Pour comprendre Node.js, il faut remonter un peu.

JavaScript est un langage de programmation créé en 1995 pour les navigateurs web. Pendant 15 ans, JavaScript ne pouvait s'exécuter que dans un navigateur — Chrome, Firefox, Safari. Si tu voulais faire tourner un programme en JavaScript sur ton ordinateur (pas dans un navigateur), c'était impossible.

En 2009, un développeur nommé Ryan Dahl a eu une idée : prendre le moteur JavaScript de Chrome (appelé V8), l'extraire du navigateur, et le faire tourner de façon autonome. C'est Node.js. C'est JavaScript libéré du navigateur. Un programme JavaScript peut maintenant tourner directement sur ton ordinateur, accéder à tes fichiers, se connecter à des bases de données, créer des serveurs web.

Pourquoi c'est pertinent pour toi : les agents CLI que tu vas installer dans les prochains modules sont distribués via npm, le gestionnaire de paquets de Node.js. Node.js est le moteur qui les fait tourner. npm est le magasin d'où tu les télécharges.

Qu'est-ce que npm ?

npm = Node Package Manager. C'est le plus grand registre de paquets logiciels au monde. Plus de 2 millions de paquets disponibles. Quand tu tapes npm install -g un-paquet, voici ce qui se passe :

• npm contacte le registre npmjs.com
• Il télécharge le paquet et toutes ses dépendances
• Il l'installe globalement (-g = global, accessible de partout) sur ton ordinateur
• Il crée un lien dans ton PATH pour que tu puisses utiliser la commande depuis n'importe quel dossier

C'est ce mécanisme que tu utiliseras pour installer tes agents CLI dans les prochains modules.

Installation de Node.js

brew install node

sudo apt install nodejs npm

nvm : gérer plusieurs versions de Node.js

Node.js sort une nouvelle version tous les 6 mois. Certains outils ont besoin de la version 20, d'autres de la 22. nvm (Node Version Manager) te permet d'installer et de basculer entre plusieurs versions en une commande. C'est optionnel pour le moment, mais c'est un bon réflexe à prendre.

Le problème que Git résout

Tu as déjà eu un dossier qui ressemblait à ça ?

rapport-final.docx
rapport-final-v2.docx
rapport-final-v2-corrigé.docx
rapport-final-VRAIMENT-final.docx
rapport-final-DERNIERE-VERSION.docx

C'est le versioning à la main. Ça marche (mal) pour un fichier. C'est complètement ingérable pour un projet de code qui contient des dizaines ou des centaines de fichiers qui changent en même temps.

Git résout ce problème. C'est un système de contrôle de version : il enregistre chaque modification, dans chaque fichier, avec un horodatage, un auteur, et un message qui explique ce qui a changé. Tu peux revenir à n'importe quel état précédent de ton projet à tout moment.

Installation de Git

sudo apt install git

Pourquoi Git est indispensable pour travailler avec des agents AI

Les agents CLI (Claude Code, Gemini, Codex) modifient tes fichiers. Ils créent du code, ils éditent du code existant, ils suppriment des choses. Sans Git, si un agent fait une erreur ou casse quelque chose, tu n'as aucun moyen de revenir en arrière. Avec Git, tu peux annuler les dernières modifications en une commande.

Claude Code utilise Git nativement. Quand il modifie des fichiers, il peut les committer (enregistrer). Quand tu veux voir ce qu'il a changé, git diff te montre exactement quoi. C'est ton filet de sécurité.

Codex va encore plus loin : il travaille dans des "worktrees" Git isolés, ce qui signifie que ses modifications sont dans une branche séparée et n'affectent pas ton code principal tant que tu n'as pas validé.

Les concepts Git essentiels (le minimum vital)

Repository (repo) — Un dossier suivi par Git. Quand tu fais git init dans un dossier, ce dossier devient un "repo". Git crée un sous-dossier caché .git/ où il stocke tout l'historique.

Commit — Un instantané de ton projet à un moment donné. Chaque commit a un message ("ajouté la page d'accueil", "corrigé le bug de connexion"), un auteur, et une date. L'historique de ton projet, c'est une suite de commits.

Branch (branche) — Une ligne de développement parallèle. Tu peux travailler sur une nouvelle fonctionnalité dans une branche sans affecter le code principal. Quand c'est prêt, tu fusionnes (merge) la branche.

GitHub — Un site web qui héberge des repos Git en ligne. C'est le Google Drive du code. Tu y stockes tes projets, tu les partages, tu collabores. GitHub n'est pas Git — Git est l'outil, GitHub est le service en ligne qui l'utilise.

Ce que tu n'as PAS besoin de maîtriser maintenant

Git est un outil profond avec des dizaines de commandes. Tu n'as pas besoin de tout savoir. Pour travailler avec des agents CLI, tu as besoin de 5 commandes : git init, git add, git commit, git status, git diff. Le reste viendra naturellement.

Qu'est-ce qu'un agent AI, précisément ?

Le mot "agent" est utilisé partout en ce moment, souvent de façon vague. Mettons une définition claire.

Un chatbot, c'est un système question-réponse. Tu poses une question, il te donne une réponse. La conversation est le produit.

Un agent, c'est un système qui poursuit un objectif. Tu lui donnes un but ("crée-moi un script qui fait X"), et il planifie les étapes, les exécute, vérifie le résultat, corrige si nécessaire, et recommence jusqu'à ce que l'objectif soit atteint. L'agent ne se contente pas de répondre — il agit.

Claude Code est un agent. Quand tu lui dis "ajoute une page de contact à mon site web", voici ce qu'il fait :

• Il lit la structure de ton projet pour comprendre comment il est organisé
• Il identifie le framework utilisé (React, Next.js, HTML pur, etc.)
• Il planifie les modifications : quels fichiers créer, quels fichiers modifier
• Il te présente son plan et demande ta permission
• Il exécute les modifications
• Il peut lancer le projet pour vérifier que ça marche
• Si ça casse, il lit l'erreur et corrige

C'est ce cycle planifier → exécuter → vérifier → corriger qui fait de Claude Code un agent et pas un simple chatbot.

Le modèle de permission

Claude Code demande ta permission avant d'agir. C'est un choix délibéré d'Anthropic. Quand l'agent veut créer un fichier, modifier un fichier, ou exécuter une commande, il te montre ce qu'il va faire et attend ton "oui" (touche Entrée) ou ton "non" (touche Échap).

Avec l'expérience, tu peux assouplir ces permissions. Mais au début, c'est une sécurité essentielle — tu gardes le contrôle total.

Ce que Claude Code voit

Quand tu lances claude dans un dossier, l'agent a accès à :

• Tous les fichiers du dossier (et sous-dossiers), sauf ceux listés dans .gitignore
• L'historique Git du projet
• Le fichier CLAUDE.md à la racine du projet (ses instructions)
• Les MCPs configurés (outils externes)
• Le contenu de ton terminal (les erreurs, les résultats de commandes)

Il n'a PAS accès à :

• Tes autres dossiers (sauf si tu le lances depuis un dossier parent)
• Tes fichiers personnels
• D'autres programmes qui tournent sur ton ordinateur

Combien ça coûte

Claude Code nécessite un abonnement Anthropic :

• Claude Pro ($20/mois) — Inclut Claude Code avec des limites d'utilisation
• Claude Max ($100/mois) — Limites beaucoup plus larges (20x), recommandé pour une utilisation intensive

Pourquoi tes instructions à l'agent comptent plus que l'agent lui-même

Voici une vérité contre-intuitive : la qualité de ce que produit un agent AI dépend à 80% de la qualité du contexte que tu lui donnes, et à 20% de la qualité du modèle lui-même.

Un agent avec un excellent CLAUDE.md produira de meilleurs résultats qu'un agent plus puissant sans instructions.

C'est comparable à l'embauche. Si tu recrutes un développeur senior et que tu lui dis "fais un site web", il va produire quelque chose de générique. Si tu lui donnes un brief détaillé — le public cible, le ton, les fonctionnalités prioritaires, les contraintes techniques, les exemples de sites qu'on aime et qu'on n'aime pas — il va produire exactement ce que tu veux.

CLAUDE.md, c'est ce brief. C'est le document que Claude Code lit en premier quand il démarre une session sur ton projet. Il conditionne tout ce que l'agent fait ensuite.

Ce que CLAUDE.md contient

CLAUDE.md est un fichier Markdown — un format de texte structuré avec des titres, des listes et du texte en gras. Il se place à la racine de ton projet.

Le contexte du projet

Qu'est-ce que ce projet ? Pour qui ? Quel problème il résout ? Un agent qui sait qu'il travaille sur "un dashboard interne pour une équipe de 5 commerciaux qui suivent 200 clients" va faire des choix très différents d'un agent qui ne sait rien.

Le stack technique

Quels langages, quels frameworks, quelles bases de données. Si tu ne le précises pas, l'agent choisit ce qu'il veut. Si tu précises "utilise Python avec Flask et SQLite", il respecte ça.

Les conventions

Comment tu veux que le code soit organisé. Quelle langue pour les commentaires (français ? anglais ?). Comment nommer les fichiers. C'est la différence entre un projet organisé et un chaos.

Les décisions déjà prises

"On a choisi Stripe pour les paiements, pas PayPal." "Le design suit le style Material Design." "Pas de framework CSS, on écrit le CSS à la main." Ces décisions évitent que l'agent refasse des choix que tu as déjà faits.

Les interdictions

"Ne jamais utiliser de données en dur (hardcoded) — toujours utiliser des variables d'environnement." "Ne pas créer de fichiers dans le dossier /assets sans demander." "Ne pas modifier le fichier de configuration de la base de données."

Les niveaux de CLAUDE.md

Claude Code lit les instructions à trois niveaux :

• Niveau global (~/.claude/CLAUDE.md) — S'applique à TOUS tes projets. Tes préférences personnelles. "Je préfère le code commenté en français." "Utilise des noms de variables explicites, jamais d'abréviations."
• Niveau projet (~/mon-projet/CLAUDE.md) — Spécifique à un projet. Le contexte, le stack, les conventions de ce projet particulier.
• Niveau sous-dossier (~/mon-projet/frontend/CLAUDE.md) — Encore plus spécifique. Les instructions pour une partie du projet.

Claude Code fusionne ces trois niveaux. Le plus spécifique l'emporte.

La place de Gemini CLI dans ta boîte à outils

Gemini CLI est l'agent de Google. Open source, construit par l'équipe Gemini, gratuit pour un usage individuel. Si Claude Code est ton architecte principal, Gemini CLI est ton éclaireur rapide.

Ses avantages distinctifs :

La fenêtre de contexte

1 million de tokens. Pour donner un ordre de grandeur : un token, c'est environ 3/4 d'un mot. 1 million de tokens, c'est environ 750 000 mots, soit l'équivalent de 10 romans. Concrètement, Gemini CLI peut avaler un projet entier — tous les fichiers, toute la documentation, tout l'historique — et le comprendre d'un bloc. Claude Code offre aussi 1 million de tokens avec Opus. La différence principale est que Gemini CLI est entièrement gratuit.

Le coût : zéro

Un généreux quota gratuit (environ 1000 requêtes/jour) avec un simple compte Google. Pas de carte bancaire, pas d'abonnement. C'est le point d'entrée idéal si tu n'as pas encore d'abonnement payant, ou si tu veux faire du brouillon rapide sans consommer tes crédits Claude.

La connexion Google native

Gemini est fait par Google. Son intégration avec les outils Google (Search, Drive, etc.) est naturelle.

Ses limites par rapport à Claude Code

Le raisonnement. Sur des tâches complexes qui demandent de la planification multi-étapes, Claude Code est en général plus fiable. Gemini peut faire des raccourcis ou oublier des contraintes sur des projets longs.

La communauté. Claude Code a une base d'utilisateurs plus large dans le monde du développement, ce qui signifie plus de ressources, plus de tutoriels, plus de solutions aux problèmes courants.

Comment Gemini CLI fonctionne

Même principe que Claude Code : tu lances gemini dans un dossier, tu parles en langage naturel, l'agent lit tes fichiers, propose des modifications, demande la permission, exécute.

Gemini CLI utilise un système de "skills" natif : des agents spécialisés pour des tâches spécifiques (revue de code, génération de tests, etc.). Ce système de skills est spécifique à Gemini CLI — on verra dans le Module 10 une approche différente pour Claude Code.

La place de Codex dans ta boîte à outils

Codex est l'agent d'OpenAI. Codex CLI est inclus avec tous les abonnements ChatGPT. OpenAI offre temporairement l'accès sur les plans gratuit et Go.

Ce qui le distingue :

Construit en Rust

Là où Claude Code et Gemini CLI sont en JavaScript/TypeScript, Codex est en Rust — un langage connu pour sa rapidité d'exécution et sa gestion de la mémoire. En pratique : Codex démarre plus vite et consomme moins de ressources.

Le système de sandbox

Codex isole ses actions dans un environnement contrôlé. Quand il exécute une commande, elle tourne dans un bac à sable qui limite l'accès au système de fichiers et au réseau. C'est la sécurité la plus stricte des trois agents.

Les modes d'approbation

Codex a trois niveaux de confiance que tu peux configurer :

• suggest — L'agent suggère, tu valides tout
• auto-edit — L'agent peut modifier des fichiers sans demander, mais demande pour les commandes
• full-auto — L'agent fait tout sans demander (à utiliser avec prudence)

Le modèle GPT-5.3-Codex

Spécifiquement optimisé pour le code. Les abonnés ChatGPT Pro ont aussi accès à GPT-5.3-Codex-Spark, une version ultra-rapide pour les tâches simples.

Le problème que les MCPs résolvent

Tes agents peuvent maintenant lire et écrire des fichiers sur ton ordinateur. C'est puissant, mais c'est un monde fermé. Ton ordinateur ne contient qu'une fraction des données et outils avec lesquels tu travailles au quotidien. Tes emails sont sur Gmail. Tes documents sont sur Google Drive. Ton calendrier est sur Google Calendar. Tes projets sont sur GitHub. Ta base client est peut-être sur Notion ou Airtable.

Pour que tes agents soient vraiment utiles dans ton travail quotidien, ils doivent pouvoir toucher à ces outils externes. C'est exactement ce que permettent les MCPs.

Qu'est-ce que le Model Context Protocol ?

MCP est un standard ouvert créé par Anthropic en 2024. L'idée est simple et élégante : définir un protocole universel qui permet à n'importe quel agent AI de se connecter à n'importe quel outil externe.

Pour comprendre, imagine un traducteur universel. Avant MCP, si tu voulais que Claude Code parle à Google Calendar, quelqu'un devait écrire un code spécifique pour cette connexion. Et si tu voulais que Claude Code parle à Notion, un autre code spécifique. Et Slack, un autre. Et GitHub, un autre. Pour chaque combinaison agent x outil, il fallait un développement dédié. Ça ne passe pas à l'échelle.

MCP standardise la connexion. Un "serveur MCP" pour Google Calendar peut être utilisé par Claude Code, par Gemini CLI, par Codex, et par n'importe quel autre outil qui parle le protocole MCP. Un serveur, tous les agents.

Comment ça marche techniquement

Un serveur MCP est un petit programme qui tourne sur ton ordinateur (ou sur un serveur distant). Il fait le lien entre l'agent et l'outil externe.

Toi → Agent (Claude Code) → Serveur MCP → Outil externe (Gmail, Calendar, etc.)
                               ↑
                    Tourne sur ton ordinateur
                    Traduit les demandes de l'agent
                    en appels API vers l'outil

Quand Claude Code veut lire tes emails, il ne parle pas directement à Gmail. Il demande au serveur MCP Gmail de le faire. Le serveur MCP traduit la demande en appels à l'API Gmail, récupère les résultats, et les renvoie à Claude Code dans un format qu'il comprend.

Chaque serveur MCP expose des "outils" (tools) que l'agent peut appeler. Par exemple, un serveur MCP Gmail pourrait exposer des outils comme :

• read_email — Lire un email spécifique
• search_emails — Chercher des emails
• send_email — Envoyer un email
• create_draft — Créer un brouillon

L'agent voit ces outils comme des capacités supplémentaires. Quand tu lui dis "envoie un email de suivi à Jean", il sait qu'il a un outil send_email disponible et l'utilise.

La sécurité

Les MCPs tournent localement, sur ton ordinateur. Tes données ne passent pas par des serveurs tiers non autorisés. L'authentification se fait via OAuth (le système "Se connecter avec Google" que tu connais) — tu autorises le serveur MCP à accéder à ton compte Google, et tu peux révoquer cet accès à tout moment.

Chaque MCP a un périmètre défini. Le MCP Gmail ne peut pas toucher à ton Calendar. Le MCP Calendar ne peut pas lire tes emails. C'est un système de permissions granulaire.

Quels MCPs on va installer

Voici un exemple de ce à quoi ressemble la configuration dans ~/.claude/settings.json :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_ton_token_ici"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@brave/brave-search-mcp-server"],
      "env": {
        "BRAVE_API_KEY": "ta_clé_ici"
      }
    }
  }
}

La différence entre MCPs et Skills

Les MCPs donnent des capacités à tes agents — la possibilité de toucher à des outils externes. Un agent avec le MCP Gmail peut envoyer des emails. Sans le MCP, il ne peut pas. C'est binaire : la capacité existe ou elle n'existe pas.

Les Skills donnent de l'expertise à tes agents — la connaissance de comment faire quelque chose de la bonne façon. Un agent peut écrire un email sans aucun skill. Mais un agent avec un skill "style de communication de mon entreprise" écrira un email qui sonne comme si c'est toi qui l'avais écrit, pas comme un template générique.

Autre façon de le voir : les MCPs sont les outils dans la boîte à outils (le marteau, le tournevis). Les Skills sont les manuels de formation (comment construire une étagère, pas juste comment planter un clou).

Comment les Skills fonctionnent dans Claude Code

Claude Code a un système de skills intégré. Un skill peut être un fichier Markdown avec des instructions, ou un skill enregistré formellement que tu invoques avec /skillname.

Tu peux les mettre :

• Dans ton CLAUDE.md directement (pour les instructions courtes)
• Dans des fichiers séparés référencés depuis le CLAUDE.md (pour les instructions longues)
• Dans un dossier skills/ à la racine de ton projet
• Dans ~/.claude/skills/ pour des skills globaux (disponibles dans tous tes projets)

Claude Code est conçu pour suivre les instructions qu'il trouve dans ces fichiers. Plus les instructions sont précises et détaillées, meilleur est le résultat.

Le skill le plus important : anti-AI writing

Le plus gros problème du contenu généré par AI, ce n'est pas qu'il est mauvais. C'est qu'il est reconnaissable. Tout le monde sait à quoi ressemble un texte écrit par ChatGPT : les "moreover", les "furthermore", les listes à puces avec des mots en gras, le ton de brochure touristique, les "it's not X — it's Y".

Le skill anti-AI writing est un document qui liste tous ces patterns reconnaissables et dit explicitement à l'agent de les éviter. C'est un ensemble de règles négatives ("ne fais JAMAIS ça") et positives ("fais plutôt ça").

Exemples de règles :

• Ne jamais commencer par "In today's fast-paced world" ou "Dans un monde en constante évolution"
• Ne jamais utiliser "moreover", "furthermore", "additionally" comme transitions
• Ne jamais faire de listes à puces avec un mot en gras suivi de deux-points
• Varier la longueur des phrases et des paragraphes
• Prendre des positions tranchées au lieu de tout nuancer
• Utiliser des détails concrets (chiffres, noms, dates) au lieu de généralités

Ce skill à lui seul transforme la qualité de tout ce que l'agent écrit.

Les plugins Claude Code

Au-delà des skills manuels, Claude Code a un système de plugins — des extensions qui ajoutent des capacités avancées directement dans l'agent. Tu les actives dans ton fichier settings.json et ils sont disponibles dans toutes tes sessions.

Voici les plugins qu'on va activer :

• frontend-design — Génère des interfaces web avec un design de qualité professionnelle
• context7 — Cherche la documentation à jour de n'importe quel framework/librairie
• feature-dev — Développement de fonctionnalités guidé avec analyse du codebase
• code-review — Revue de code automatique avec détection de bugs et vulnérabilités
• commit-commands — Commandes Git avancées (commit, push, PR en une commande)
• superpowers — Brainstorming, plans d'implémentation, débogage systématique, TDD
• code-simplifier — Simplifie et nettoie le code automatiquement
• typescript-lsp / pyright-lsp — Analyse de code en temps réel (TypeScript et Python)
• claude-md-management — Gestion intelligente de tes fichiers CLAUDE.md
• skill-creator — Crée de nouveaux skills automatiquement
• firebase — Intégration Firebase/Firestore
• firecrawl — Scraping web et extraction de contenu

Ce qu'on va installer

On va installer 2 choses :

• Le settings.json — Active tous les plugins et les bonnes permissions
• 4 skills personnalisés — Anti-AI writing, Google Workspace, MVP builder, Code reviewer

Ce que tu vas construire

Ce module est le point culminant de tout le programme. Tu vas construire un vrai outil, de A à Z, en utilisant tout ce que tu as installé et appris. Pas un exercice d'entraînement — un outil que tu pourras réellement utiliser dans ton travail.

Le parcours dépend de ce que tu as choisi dans le questionnaire d'entrée. Chaque parcours utilise les mêmes principes (CLAUDE.md, MCPs, skills, Git) mais produit un résultat différent.

La méthode est toujours la même :

• Décrire ce qu'on veut construire (le brief)
• Créer le dossier projet avec Git et CLAUDE.md
• Demander à l'agent de scaffolder (créer la structure de base)
• Itérer fonctionnalité par fonctionnalité
• Tester chaque étape
• Documenter
• (Optionnel) Déployer

Comment travailler efficacement avec un agent sur un projet de plusieurs heures

Commence petit, itère vite

Ne demande pas à l'agent de construire tout d'un coup. "Crée la structure de base avec un seul endpoint qui retourne Hello World" → teste → "Maintenant ajoute la lecture du spreadsheet" → teste → "Maintenant ajoute le filtrage" → teste. Chaque étape est un commit Git.

Décris l'intention, pas l'implémentation

"Je veux pouvoir filtrer mes contacts par date de dernier contact" est meilleur que "crée une fonction filter_by_date qui prend un paramètre datetime et fait un list comprehension sur...". Laisse l'agent choisir l'implémentation. C'est son expertise.

Quand ça casse, donne le contexte

Si une erreur apparaît, ne dis pas juste "ça marche pas". Copie-colle l'erreur complète et dis "cette erreur apparaît quand je fais [action]". L'agent a besoin du contexte pour diagnostiquer.

Committe souvent

Après chaque fonctionnalité qui marche, demande à l'agent de committer. C'est ton filet de sécurité.

Les 4 parcours possibles

Le parcours que tu vas suivre dépend de l'objectif que tu as choisi dans le questionnaire d'entrée. Lis le parcours qui te correspond et suis les instructions :

Parcours A — Mon assistant email (Google Workspace)

Objectif : créer un script qui lit tes 10 derniers emails Gmail, les résume avec un agent AI, et écrit le résumé dans un Google Sheet.

• Brief à donner à l'agent : "Crée un script qui se connecte à Gmail via l'API, récupère mes 10 derniers emails, utilise un LLM pour résumer chaque email en une phrase, et écrit le résultat dans un Google Sheet avec les colonnes : Expéditeur, Objet, Résumé, Date."
• Commence par la connexion Gmail seule (récupérer les emails)
• Ajoute le résumé AI (appel à Gemini ou Claude)
• Ajoute l'écriture dans Google Sheets
• Teste avec tes vrais emails

Parcours B — Mon tracker client (outil interne)

Objectif : créer un dashboard qui affiche les métriques de ton business depuis un fichier CSV.

• Brief à donner à l'agent : "Crée une application web locale qui lit un fichier CSV de données clients (nom, email, date d'inscription, montant payé, dernier contact) et affiche un dashboard avec : nombre total de clients, revenu total, clients actifs vs inactifs, et un tableau filtrable."
• Commence par la lecture du CSV et l'affichage brut
• Ajoute les métriques calculées (totaux, moyennes)
• Ajoute le tableau avec filtres et tri
• Ajoute un graphique simple (évolution du revenu)

Parcours C — Ma landing page (site web)

Objectif : créer une landing page pour ton produit avec un formulaire de contact.

• Brief à donner à l'agent : "Crée une landing page pour [ton produit/service] avec : un hero section avec titre accrocheur et sous-titre, une section bénéfices (3-4 points), une section témoignages, un formulaire de contact (nom, email, message) qui envoie les données dans un fichier JSON local, et un footer."
• Commence par la structure HTML/CSS de base
• Ajoute le contenu section par section
• Ajoute le formulaire fonctionnel
• Peaufine le design (responsive, animations subtiles)

Parcours D — Mon outil au choix (semi-guidé)

Objectif : choisis un outil dont tu as besoin au quotidien et construis-le.

• Décris ton besoin en une phrase : "J'ai besoin d'un outil qui..."
• Demande à l'agent de proposer une architecture simple
• Valide l'approche, puis commence par la fonctionnalité principale
• Itère : une fonctionnalité → test → commit → fonctionnalité suivante
• Arrête quand l'outil fait ce que tu voulais au départ

Ce que tu as construit

Tu es parti d'un ordinateur sans aucun outil de développement installé. Tu as maintenant :

Un environnement de travail professionnel

Ghostty configuré, Git opérationnel, Node.js installé. Les mêmes outils que ceux utilisés par des développeurs seniors dans des boîtes de la Silicon Valley.

Jusqu'à trois agents AI à ta disposition

Claude Code pour le travail de fond, Gemini CLI pour l'exploration rapide et gratuite, Codex pour l'écosystème OpenAI. Tu peux les comparer, les combiner, et choisir le meilleur pour chaque situation.

Des connexions à tes outils quotidiens

Tes agents peuvent lire tes emails, modifier tes spreadsheets, gérer ton calendrier, chercher sur le web. Et si tu as configuré les APIs Google (Module 11), tes scripts peuvent même automatiser ces tâches sans toi.

Des skills qui spécialisent tes agents

Écriture anti-AI, automatisation Google, construction de MVP, revue de code — 4 skills qui transforment un agent générique en assistant calibré pour ton activité.

Un vrai outil fonctionnel

Le MVP que tu as construit au Module 12 n'est pas un exercice. C'est un outil que tu peux utiliser, améliorer, et sur lequel tu peux construire.

Les 4 compétences clés que tu maîtrises

• Configurer et piloter des agents AI dans un terminal (Claude Code, Gemini CLI, Codex)
• Structurer un projet avec Git, CLAUDE.md et des skills pour que l'agent produise du travail de qualité
• Connecter tes agents à tes outils quotidiens via les MCPs (Google, web, fichiers)
• Construire un outil complet de A à Z en donnant des instructions claires et en itérant

La suite

Ce programme t'a donné les fondations. À partir d'ici :

Construis

Le meilleur apprentissage, c'est de construire des choses dont tu as réellement besoin. Un outil de facturation, un dashboard de suivi, un système de newsletter automatisé. Chaque projet renforce tes compétences.

Affine tes skills

Les 4 skills de base (écriture anti-AI, automatisation Google, construction de MVP, revue de code) sont un point de départ. Crée des skills pour ton domaine spécifique. Un skill "ton de communication de ma marque", un skill "processus de vente de mon équipe", un skill "format de reporting pour mes investisseurs".

Explore les MCPs

Il en existe des centaines. Notion, Slack, Airtable, Stripe, PostgreSQL, Supabase... Chaque MCP que tu ajoutes étend les capacités de tes agents.

Reste flexible

L'IA évolue à une vitesse folle. Les outils que tu utilises aujourd'hui seront peut-être remplacés dans 6 mois. Ce qui ne changera pas, c'est ta capacité à travailler dans un terminal, à configurer des agents, et à décrire clairement ce que tu veux. Ce sont ces méta-compétences que ce programme t'a données.