# Installer son premier agent de code : Claude Code, Codex, Vibe

> Installer Claude Code, Codex, Mistral Vibe ou Gemini CLI, se connecter et mener un premier petit projet en relisant chaque action de l'agent avant de valider.

- Niveau : Amateur
- Thème : Code
- Durée : 20 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/premier-agent-de-code/

Un assistant comme ChatGPT ou Claude répond dans une fenêtre de discussion, et vous recopiez ensuite son code à la main. Un agent de code travaille directement dans le dossier de votre projet. Il lit les fichiers, en modifie plusieurs d'affilée, lance les tests ou le serveur, lit les erreurs et recommence jusqu'à ce que ça marche. Vous décrivez la tâche avec vos mots, il propose les actions, et vous validez.

## Comment ça marche

![L'agent travaille en boucle dans le dossier du projet : il propose, vous validez, il agit, puis il lit le résultat avant l'étape suivante.](https://quelleia.com/guides/premier-agent-de-code/boucle-agent-de-code.svg)

*L'agent travaille en boucle dans le dossier du projet : il propose, vous validez, il agit, puis il lit le résultat avant l'étape suivante.*

L'agent tourne en boucle. Il lit les fichiers utiles, propose une action (modifier tel fichier, lancer telle commande), attend votre accord, l'exécute, puis lit le résultat : un test qui passe, un message d'erreur, une page qui s'affiche. Il en déduit l'action suivante, et ainsi de suite jusqu'au bout de la tâche. Le modèle d'IA décide de chaque action, que le programme installé sur votre machine exécute pour lui.

## À quoi ça sert

- **Créer un petit outil sans savoir programmer** : une page web, un script qui renomme vos photos par date, un tableau de suivi de dépenses.
- **Corriger une erreur** : vous collez le message, l'agent cherche la cause dans le code et propose le correctif.
- **Comprendre un projet inconnu** : « explique-moi comment ce dépôt est organisé et où se trouve la connexion des utilisateurs ».
- **Écrire les tests** d'un code existant, puis les lancer.
- **Configurer une machine** : installer un logiciel, régler un service, en vous montrant chaque commande avant de la lancer.

Ce guide couvre les quatre agents en ligne de commande des grands éditeurs : Claude Code (Anthropic), Codex (OpenAI), Mistral Vibe (Mistral AI) et Gemini CLI (Google). Ils fonctionnent sur le même principe, et ce que vous apprenez avec l'un se transpose aux autres.

## Ce qu'il vous faut avant de commencer

Trois choses suffisent. D'abord un terminal : Terminal sur Mac, PowerShell ou Windows Terminal sous Windows, n'importe quel terminal sous Linux. Ensuite un dossier de projet, même vide. Enfin un compte chez l'éditeur, car l'agent est gratuit à installer mais le modèle qui le fait réfléchir se paie, par abonnement ou à l'usage.

Les conditions d'accès diffèrent d'un outil à l'autre :

- **Claude Code** demande un abonnement Claude payant (Pro, Max, Team ou Enterprise) ou un compte Console payé à l'usage. La formule gratuite de claude.ai n'y donne pas accès.
- **Codex** passe par votre compte ChatGPT (bouton « Sign in with ChatGPT » au premier lancement) ou par une clé d'API. La fiche de l'outil détaille quelles formules ouvrent la ligne de commande.
- **Mistral Vibe** accepte un compte Mistral, gratuit avec un accès limité, ou une clé d'API, d'après la page d'installation de Mistral.
- **Gemini CLI** a changé de statut le 18 juin 2026. Google ne le sert plus aux comptes gratuits ni aux abonnés Google AI Pro et Ultra, qu'il oriente vers Antigravity CLI. Il reste utilisable avec une clé d'API payante ou une licence Gemini Code Assist Standard ou Enterprise.

Les prix de chaque formule, relevés en France, sont sur la page [Abonnements](https://quelleia.com/abonnements/).

## Lequel choisir

Le plus simple consiste à partir de l'abonnement que vous payez déjà : Codex avec ChatGPT, Claude Code avec Claude, Vibe avec Mistral. Le tableau ci-dessous, tiré du relevé des outils de QUELLE IA, indique combien de modèles classés chaque outil propose.

**Les outils de code suivis**

1. [OpenCode](https://quelleia.com/outils/opencode/) : 87 modèles (Anomaly)
2. [Droid (Factory)](https://quelleia.com/outils/factory-droid/) : 56 modèles (Factory)
3. [Cursor](https://quelleia.com/outils/cursor/) : 55 modèles (Anysphere)
4. [Devin Desktop (ex-Windsurf)](https://quelleia.com/outils/devin-desktop/) : 41 modèles (Cognition)
5. [JetBrains AI Assistant](https://quelleia.com/outils/jetbrains-ai-assistant/) : 38 modèles (JetBrains)
6. [Warp](https://quelleia.com/outils/warp/) : 37 modèles
7. [Zed](https://quelleia.com/outils/zed/) : 31 modèles (Zed Industries)
8. [Augment Code](https://quelleia.com/outils/augment/) : 29 modèles (Augment Code)

Nombre de modèles classés sur QUELLE IA que chaque outil propose, d'après sa propre liste, relevée au plus tard le 16 novembre 2026.
[Les 25 outils de code et agents](https://quelleia.com/outils/)

Le modèle compte autant que l'outil. Le classement Code de QUELLE IA mesure les modèles sur des tâches de programmation : il aide à voir quel éditeur mène en ce moment.

**Le haut du classement Code**

1. [Claude Opus 5.5](https://quelleia.com/modeles/claude-opus-5-5/) : 101,4 (Anthropic)
2. [Gemini 4 Carbon](https://quelleia.com/modeles/gemini-4-carbon/) : 100,6 (Google DeepMind)
3. [Claude Fable 5.1](https://quelleia.com/modeles/claude-fable-5-1/) : 100,1 (Anthropic)
4. [Claude Sonnet 5.5](https://quelleia.com/modeles/claude-sonnet-5-5/) : 99,8 (Anthropic)
5. [GPT-6 Astra](https://quelleia.com/modeles/gpt-6-astra/) : 99,3 (OpenAI)

Score Code, édition du 16 novembre 2026. Deux modèles dont les marges se recouvrent sont ex æquo.
[Classement Code des modèles de langage](https://quelleia.com/classement/code/)

> Bon à savoir : un même modèle obtient des résultats différents selon l'outil qui le pilote. Le guide [Harnais](https://quelleia.com/guides/harnais/) explique pourquoi.

## Installer l'agent

Chaque agent s'installe par une commande à copier dans le terminal. Les commandes ci-dessous sont recopiées des pages officielles et relues à chaque construction du site.

### Claude Code

**Installer Claude Code**

macOS, Linux, Windows par WSL :

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

Windows (PowerShell) :

```bash
irm https://claude.ai/install.ps1 | iex
```

Windows (CMD) :

```bash
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```

macOS (Homebrew) :

```bash
brew install --cask claude-code
```

Windows (WinGet) :

```bash
winget install Anthropic.ClaudeCode
```

Tous systèmes (npm, Node.js 22 ou plus récent) :

```bash
npm install -g @anthropic-ai/claude-code
```

D'après https://code.claude.com/docs/en/setup (lue le 3 octobre 2026).

Ouvrez ensuite un nouveau terminal pour que la commande `claude` soit reconnue, puis vérifiez l'installation avec `claude --version`. Placez-vous dans le dossier du projet et lancez `claude`. Au premier lancement, la connexion se fait dans le navigateur.

### Codex

**Installer Codex**

macOS, Linux :

```bash
curl -fsSL https://chatgpt.com/codex/install.sh | sh
```

Windows (PowerShell) :

```bash
powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"
```

Tous systèmes (npm) :

```bash
npm install -g @openai/codex
```

macOS (Homebrew) :

```bash
brew install --cask codex
```

D'après https://learn.chatgpt.com/docs/codex/cli (lue le 3 octobre 2026).

Lancez `codex` dans le dossier du projet. Choisissez « Sign in with ChatGPT », ou une autre méthode de connexion si vous avez une clé d'API. La commande `/model` change ensuite de modèle et règle l'effort de raisonnement quand le modèle le propose.

### Mistral Vibe

**Installer Mistral Vibe**

macOS et Linux :

```bash
curl -LsSf https://mistral.ai/vibe/install.sh | bash
```

Installation manuelle (Python 3.12 ou plus récent) :

```bash
uv tool install mistral-vibe
pip install mistral-vibe
```

Windows :

```bash
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
uv tool install mistral-vibe
```

D'après https://docs.mistral.ai/vibe/code/cli/install-setup (lue le 3 octobre 2026).

Le script d'installation pose aussi `uv`, l'outil Python dont Vibe a besoin. Lancez `vibe` à la racine du projet : un assistant vous propose de vous connecter avec votre compte Mistral ou de coller une clé d'API. Pour le relancer plus tard, tapez `vibe --setup`.

### Gemini CLI

**Installer Gemini CLI**

Tous systèmes (Node.js 20 ou plus) :

```bash
npm install -g @google/gemini-cli
```

Tous systèmes, sans installation (npx) :

```bash
npx @google/gemini-cli
```

D'après https://geminicli.com/docs/get-started/installation/ (lue le 3 octobre 2026).

Gemini CLI demande Node.js 20 ou plus récent. Créez une clé d'API dans Google AI Studio, placez-la dans la variable `GEMINI_API_KEY`, puis lancez `gemini` dans le dossier du projet.

```bash
export GEMINI_API_KEY="votre_clé"
gemini
```

Sous Windows PowerShell, la première ligne s'écrit `$env:GEMINI_API_KEY="votre_clé"`. Si vous avez un abonnement Google AI Pro ou Ultra, regardez plutôt la fiche d'[Antigravity CLI](https://quelleia.com/outils/antigravity-cli/), l'outil vers lequel Google vous renvoie.

## Vérifier l'installation

Dans un nouveau terminal, demandez la version de l'agent installé. Une réponse avec un numéro confirme que le terminal trouve la commande. Pour Vibe et Gemini CLI, lancer simplement `vibe` ou `gemini` dans le dossier du projet fait le même test.

```bash
claude --version
codex --version
```

![Terminal où la commande claude --version répond 2.1.323 (Claude Code) et la commande codex --version répond codex-cli 0.166.0.](https://quelleia.com/guides/premier-agent-de-code/versions-agents.webp)

*Sortie réelle relevée le 17 novembre 2026 sur le mini-PC de QUELLE IA, où Claude Code et Codex sont installés.*

## Votre premier projet étape par étape

Prenez un projet minuscule pour la première fois : une page web qui affiche la météo d'une ville, un script qui renomme des photos par date, un petit jeu en Python. L'enjeu est d'apprendre le rythme de travail avec l'agent.

1. Créez un dossier vide et ouvrez un terminal dedans. Tapez `git init` : Git gardera une trace de chaque version, et vous pourrez revenir en arrière si l'agent casse quelque chose.
2. Lancez l'agent (`claude`, `codex`, `vibe` ou `gemini`).
3. Décrivez l'objectif plutôt que les commandes. Par exemple : « Je veux une page web toute simple qui affiche la météo de Lyon à partir d'une API gratuite. Propose-moi d'abord un plan en trois étapes et attends mon accord avant d'écrire du code. »
4. Lisez le plan. Si une étape vous paraît obscure, demandez pourquoi avant d'accepter.
5. Laissez l'agent écrire les fichiers. Avant chaque commande, il vous demande l'autorisation : lisez-la, puis acceptez ou refusez.
6. Testez vous-même le résultat. Si quelque chose ne marche pas, copiez le message d'erreur dans la conversation. L'agent le lit et corrige.
7. Quand la version vous convient, demandez-lui d'enregistrer le travail dans Git avec un message clair (un commit). Vous avez un point de retour sûr.

> Bon à savoir : un agent va vite et doute rarement de lui. Votre rôle consiste à relire, et vous n'avez pas besoin de connaître chaque commande pour le tenir. Approuvez ce que vous comprenez et questionnez le reste.

## Le fichier de consignes du projet

Chaque agent lit au démarrage un fichier texte placé à la racine du projet. Vous y écrivez ce qu'il doit savoir à chaque session : le langage, la commande des tests, les règles à respecter. Le format AGENTS.md est un standard ouvert, lu par Codex, Gemini CLI, OpenCode, Cursor, GitHub Copilot et d'autres. Claude Code lit CLAUDE.md, et peut aussi reprendre un AGENTS.md existant depuis ses versions récentes. Gemini CLI a en plus son propre GEMINI.md.

Inutile de l'écrire à la main. Dans Claude Code comme dans Codex, la commande `/init` analyse le projet et rédige un premier fichier, que vous corrigez ensuite. Anthropic conseille de rester sous 200 lignes : un fichier trop long occupe la mémoire de travail du modèle et se trouve moins bien suivi.

```markdown
# Projet météo
- Page web statique : index.html, style.css, app.js.
- Toujours montrer le plan avant de modifier plusieurs fichiers.
- Aucune clé d'API dans le code : la lire dans le fichier .env.
```

## Garder la main

Les quatre agents demandent votre accord avant d'écrire un fichier ou de lancer une commande, et chacun permet d'élargir ces autorisations. Dans Codex, `/permissions` règle ce qu'il peut faire sans demander. Gardez les réglages par défaut tant que vous découvrez l'outil.

Quelques réflexes évitent les mauvaises surprises :

- Travaillez toujours dans un dossier suivi par Git, et enregistrez souvent. Un `git diff` vous montre exactement ce que l'agent a changé.
- Ne collez jamais une clé d'API ou un mot de passe dans la conversation. Rangez-les dans un fichier `.env` exclu de Git.
- Une tâche à la fois. Un agent qui fait trois choses en même temps produit un historique illisible.
- Pour faire travailler deux sessions en parallèle sur le même projet, donnez à chacune sa copie de travail. Claude Code le fait avec `claude --worktree nom`, qui crée une copie séparée sur sa propre branche.

Une fois cette base prise, vous pouvez brancher l'agent sur un modèle qui tourne chez vous, lui ajouter des outils par MCP ou lui apprendre vos procédures avec des skills. Les guides suivants détaillent chacune de ces étapes.

## Pour aller plus loin

- [Outils de code et agents](https://quelleia.com/outils/)
- [Classement Code des modèles de langage](https://quelleia.com/classement/code/)
- [Les assistants grand public](https://quelleia.com/abonnements/)
- [Claude Code](https://quelleia.com/outils/claude-code/)
- [Codex](https://quelleia.com/outils/codex/)
- [Mistral Vibe](https://quelleia.com/outils/mistral-vibe/)
- [Gemini CLI](https://quelleia.com/outils/gemini-cli/)
- [Brancher Ollama dans un agent de code](https://quelleia.com/guides/agent-de-code-avec-un-modele-local.md) (guide, expert)
- [Configurer OpenCode : opencode.json, modèles, agents, permissions](https://quelleia.com/guides/opencode-configuration.md) (guide, expert)
- [Harnais : pourquoi un même modèle change d'un outil à l'autre](https://quelleia.com/guides/harnais.md) (guide, amateur)
- [MCP : brancher des outils dans Claude, ChatGPT ou un agent](https://quelleia.com/guides/mcp.md) (guide, amateur)
- [Skills, plugins, extensions : enrichir son agent de code](https://quelleia.com/guides/skills-et-plugins.md) (guide, expert)
- [Sur mini lab AI](https://minilabai.com/guides/installer-l-agent/) : un guide du même auteur, qui va plus loin

## Sources

- https://learn.chatgpt.com/docs/codex/cli (lue le 17 novembre 2026)
- https://docs.mistral.ai/vibe/code/cli/install-setup (lue le 17 novembre 2026)
- https://developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli (lue le 17 novembre 2026)
- https://code.claude.com/docs/en/memory (lue le 17 novembre 2026)
- https://agents.md/ (lue le 17 novembre 2026)
- https://code.claude.com/docs/en/worktrees (lue le 17 novembre 2026)
