- Claude Code : Chat, Terminal, Cowork — comparatif

Trois interfaces, un même moteur

Claude Code n'est pas un outil unique : c'est une famille d'interfaces qui partagent le même modèle (Claude Opus, Sonnet, Haiku) et les mêmes capacités d'agent — lecture/écriture de fichiers, exécution de commandes, navigation web, appel d'API. Ce qui change, c'est le contexte d'exécution : votre navigateur, votre terminal local, ou un sandbox cloud managé par Anthropic.

Beaucoup de développeurs confondent encore Claude Chat (l'interface conversationnelle de claude.ai), Claude Code CLI (la commande claude installée localement) et Claude Code Cowork (l'environnement collaboratif cloud). Choisir le mauvais outil pour la tâche peut coûter cher en quota, en frustration ou en sécurité.

Ce guide compare en profondeur les trois interfaces : installation pas-à-pas, points forts, limites, et critères pour choisir la bonne porte d'entrée selon votre besoin. À la fin, vous saurez quand sortir un terminal, ouvrir un navigateur, ou lancer une session cloud.

Claude Code Chat — l'interface web claude.ai

Le Chat est la porte d'entrée la plus accessible. Tout se passe dans le navigateur, sans installation. Vous ouvrez claude.ai, vous tapez votre question, et Claude répond. C'est l'interface utilisée pour générer du code à copier, expliquer un concept, débugger un message d'erreur ou rédiger une documentation.

Installation et premier démarrage

Aucune installation logicielle. Le parcours se résume à trois étapes :

# 1. Ouvrir le navigateur
https://claude.ai

# 2. Créer un compte (email, Google ou SSO entreprise)
# 3. Choisir un plan
#    - Free  : conversations limitées, modèle Haiku/Sonnet
#    - Pro   : Sonnet illimité (raisonnable), Opus limité
#    - Max   : Opus large, projets et MCP avancé

Fonctionnalités-clés du Chat

• Projects : conteneurs persistants pour grouper des conversations + des fichiers de contexte (jusqu'à 200K tokens partagés).
• Artifacts : zone visuelle pour afficher du code, du HTML ou des diagrammes en preview live à côté du chat.
• Computer Use (Max) : Claude peut contrôler un navigateur virtuel pour exécuter des actions web.
• MCP Connectors : connexion à des outils externes (GitHub, Gmail, Notion, Linear) directement depuis l'interface.

Exemple d'usage typique

Prompt : "Voici mon erreur Angular SSR : NG0506. Voici mon app.config.ts.
Identifie la cause et propose un patch minimal."

Claude analyse l'erreur, lit le fichier collé, retourne :
- Diagnostic (cause racine)
- Patch en bloc de code prêt à copier
- Test de validation

Avantages du Chat

• Zéro installation — fonctionne sur n'importe quel poste, y compris partagé ou verrouillé en entreprise.
• Multi-device — l'historique est synchronisé entre votre laptop, votre mobile et votre tablette.
• Artifacts visuels — voir un composant React s'afficher en preview live, modifier le SVG d'un logo, tester un snippet HTML.
• Sans risque pour le système — Claude n'a aucun accès direct à vos fichiers, vous gardez 100% du contrôle copier-coller.
• Inclus dès le plan Free — premier réflexe pour découvrir l'écosystème.

Inconvénients du Chat

• Copier-coller manuel — vous devez extraire le code, le coller dans votre IDE, vérifier la cohérence des chemins.
• Pas d'exécution réelle — Claude n'exécute pas vos tests, ne lance pas vos scripts, ne lit pas votre vrai filesystem.
• Contexte limité au prompt — au-delà de quelques fichiers collés, le contexte devient fragile.
• Pas de boucle d'agent autonome — pour chaque étape, vous re-prompttez ; pas de plan multi-tâches qui s'auto-exécute.
• Quotas message-based — sur Pro, vous pouvez atteindre la limite plus vite qu'avec la CLI (qui réutilise le cache de prompt).

Pourquoi choisir le Chat ?

Parce que le coût d'entrée est nul, parce qu'il est sûr (rien ne s'exécute sur votre machine), et parce qu'il reste le meilleur compagnon pour les tâches courtes, exploratoires ou créatives : comprendre un concept, brainstormer une architecture, demander une review de code copié-collé, ou produire un draft de documentation. C'est aussi l'interface où Artifacts brille pour itérer sur du HTML/CSS/JS visuel.

Claude Code Terminal — la CLI locale

Claude Code CLI est l'outil ligne de commande officiel d'Anthropic, distribué via npm. Il transforme votre terminal en agent IA capable de lire/écrire vos fichiers, exécuter vos scripts, lancer vos tests, faire des commits Git, ouvrir des PR — tout cela en restant 100% sur votre machine. C'est l'interface que les développeurs utilisent au quotidien pour du code de production.

Installation pas-à-pas

Pré-requis : Node.js 18 ou supérieur (LTS recommandé). Vérification rapide :

# 1. Vérifier Node.js
node --version
# Doit afficher v18.x.x ou plus récent

# 2. Installer Claude Code globalement
npm install -g @anthropic-ai/claude-code

# 3. Vérifier l'installation
claude --version
# Affiche : claude-code 2.x.x

Première session

# Se placer dans le projet
cd ~/projects/mon-app

# Lancer Claude Code
claude

# Au premier lancement :
# - Un navigateur s'ouvre pour valider votre compte Anthropic
# - Choisir le modèle par défaut (Sonnet ou Opus)
# - Accepter le mode de permissions (ask / allow / deny)

Configuration Windows / WSL2

Sous Windows, deux options se valent — WSL2 reste recommandé pour la compatibilité totale des outils Unix.

# Option A : PowerShell natif (Windows 11+)
# Installer Node.js LTS depuis nodejs.org puis :
npm install -g @anthropic-ai/claude-code
claude

# Option B : WSL2 + Ubuntu (recommandé)
wsl --install -d Ubuntu-22.04
# Dans Ubuntu :
sudo apt update && sudo apt install -y nodejs npm
npm install -g @anthropic-ai/claude-code

Fichier de configuration projet

Claude Code lit automatiquement un fichier CLAUDE.md à la racine du dépôt pour récupérer les conventions, les commandes habituelles et les règles métier. Voici un squelette minimal :

# MonProjet — Configuration Claude Code

## Démarrage
- Dev : `npm start`
- Tests : `npm test`
- Build : `npm run build`

## Conventions
- Composants Angular : standalone uniquement
- Tests : Vitest + Testing Library
- Commits : Conventional Commits

## Pièges connus
- Le service `AuthService` cache son token 5 min — bien invalider après reset
- Ne JAMAIS modifier `dist/`, c'est généré

Commandes utiles du quotidien

# Mode interactif (REPL)
claude

# Tâche unique avec auto-exécution
claude "Ajoute un endpoint /health qui renvoie {status: 'ok'}"

# Permissions souples pour une session
claude --permission-mode acceptEdits

# Reprendre la dernière session
claude --resume

# Définir un modèle plus rapide
claude --model claude-haiku-4-5

# Lancer en mode plan (planifie sans toucher au code)
claude --plan

Slash commands intégrées

/help            → liste toutes les commandes
/config          → ouvre les paramètres
/init            → génère un CLAUDE.md initial
/clear           → vide la conversation
/compact         → résume le contexte pour libérer des tokens
/review          → review du diff courant
/agents          → lister/créer/éditer les sous-agents
/mcp             → gérer les serveurs MCP connectés

Sous-agents et hooks

Claude Code CLI permet de définir des sous-agents spécialisés (revue de sécurité, tests, doc) et des hooks shell qui se déclenchent sur des événements (avant/après commit, sur écriture de fichier). C'est ce qui transforme la CLI en plateforme d'automatisation, pas juste un assistant code.

// .claude/settings.json — exemple de hook
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          { "type": "command", "command": "npx prettier --write \"$CLAUDE_FILE\"" }
        ]
      }
    ]
  }
}

Avantages du Terminal CLI

• Action directe sur le code — Claude lit, écrit, refactorise réellement vos fichiers, sans copier-coller.
• Exécution réelle — tests, builds, scripts npm, Docker, Git : tout est lancé avec l'environnement de votre machine.
• Contexte projet complet — grâce à CLAUDE.md et à la lecture native du repo, Claude comprend votre stack.
• Boucle d'agent autonome — plan multi-étapes, retry, vérification : Claude itère tout seul jusqu'au résultat.
• Hooks et sous-agents — automatiser des chaînes (review → tests → commit) avec validation humaine où ça compte.
• Compatible MCP — connecter des serveurs Model Context Protocol pour étendre les capacités (DB, API privées, design system).
• Cache de prompt — la CLI ré-utilise efficacement le cache Anthropic, donc usage long marathon moins coûteux.

Inconvénients du Terminal CLI

• Risque d'écriture non intentionnée — sans relecture, Claude peut casser un fichier ; toujours valider les diffs.
• Quota plan-based — un usage intensif (refactos longs) draine vite un Pro ; Max 5x/20x est presque obligatoire.
• Dépendance Node.js — il faut un environnement Node.js maintenu (LTS).
• Onboarding plus technique — comprendre les permissions, hooks et MCP demande de la lecture.
• Pas pensé pour le partage — la session vit sur votre machine, difficilement transférable à un coéquipier en temps réel.
• Sécurité à cadrer — un agent qui exécute du shell peut faire des dégâts si CLAUDE.md ou les hooks sont mal écrits.

Pourquoi choisir le Terminal CLI ?

Parce que c'est l'outil de production : il opère vraiment sur votre code, exécute vos tests, fait vos commits, ouvre vos PR. C'est l'interface à privilégier pour les tâches qui demandent un cycle complet — diagnostic → fix → vérification → commit — sans copier-coller intermédiaire. Le cache de prompt et les hooks personnalisés en font aussi la plus économique pour les marathons de refacto.

Claude Code Cowork — l'environnement cloud collaboratif

Cowork est la couche cloud officielle pour faire tourner Claude Code en dehors de votre machine. Anthropic vous fournit un environnement Linux managé, isolé par session, où Claude exécute le code à votre place — pendant que vous fermez votre laptop ou que vous partagez la session avec un coéquipier. C'est la réponse aux deux limites de la CLI locale : la durée des tâches longues et le travail d'équipe.

Concept et architecture

Une session Cowork = un sandbox Linux + Claude Code CLI + une connexion sécurisée à votre dépôt Git :

• L'environnement est éphémère par défaut : il s'éteint à la fin de la session ou après inactivité.
• Le dépôt Git est cloné dans le sandbox via un connecteur GitHub/GitLab/Bitbucket.
• L'agent peut tourner pendant des heures sans bloquer votre machine.
• Plusieurs personnes peuvent rejoindre la même session, voir le terminal en temps réel, prendre la main.

Activation et premier accès

# 1. Vérifier que votre plan le permet (Max 5x ou Max 20x, ou Team)
# 2. Ouvrir https://claude.ai/cowork (ou via le menu Apps)
# 3. Connecter votre fournisseur Git (GitHub par défaut)
# 4. Autoriser Anthropic à accéder aux dépôts choisis
# 5. Cliquer "New session" → choisir le repo et la branche

Lancer Claude Code dans Cowork

Une fois la session démarrée, vous obtenez un terminal cloud sur lequel Claude Code est déjà installé et authentifié :

# Dans la session Cowork (terminal cloud)
cd /workspace/mon-app
claude

# La session démarre sans demander d'authentification — déjà liée à votre compte
# Vous pouvez lancer une tâche longue puis fermer l'onglet :
claude "Migre tout l'app vers Angular 19 standalone, lance les tests \
        et propose un PR par étape"

Reprise et reconnexion

Toute session Cowork a un identifiant unique. Vous pouvez fermer votre navigateur, revenir 2 heures plus tard, l'agent a continué à travailler. Vous voyez le journal complet de ce qu'il a fait, vous reprenez la main si besoin.

# Lister vos sessions actives
# (via l'UI Cowork ou la commande)
claude session list

# Reprendre une session
claude session resume sess_abc123

# Fermer une session pour libérer les ressources
claude session end sess_abc123

Partage et collaboration temps réel

# Inviter un coéquipier par email ou lien
# Permissions : view-only ou co-pilot
# Le coéquipier voit le même terminal, peut prompter Claude,
# et peut prendre temporairement la main pour valider un commit

Avantages de Cowork

• Tâches longues sans bloquer la machine — refactos massifs, scans de sécurité, audits multi-repo.
• Sandbox jetable — l'agent peut npm install, lancer Docker, modifier des fichiers système : tout meurt à la fin.
• Collaboration temps réel — coder en duo avec Claude et un coéquipier dans le même terminal.
• Environnement reproductible — chaque session démarre propre, idéal pour des démos ou un onboarding.
• Parallélisation — lancer 5 sessions en parallèle pour 5 features distinctes.
• Aucun risque pour votre poste — l'agent ne touche jamais votre filesystem local.
• Audit et journal complets — toutes les actions sont loggées côté Anthropic, utiles en équipe.

Inconvénients de Cowork

• Plan premium requis — Max 5x/20x ou Team, le coût mensuel est sensible.
• Dépendance internet — pas de mode offline ni de connectivité dégradée tolérée.
• Latence terminal — légèrement plus lent qu'un shell local, perceptible sur les tâches interactives.
• Sandbox éphémère par défaut — il faut commiter et pusher pour conserver le travail.
• Accès aux services privés à configurer — bases de données internes, APIs derrière VPN demandent un setup réseau.
• Code transite par le cloud Anthropic — soumis à la politique de rétention de l'entreprise ; à valider avec votre équipe sécurité.

Pourquoi choisir Cowork ?

Parce qu'il déplace le bottleneck : ce n'est plus votre laptop qui doit rester ouvert pendant 3 heures. Cowork est l'outil quand la tâche est longue, parallèle ou collaborative — un audit de sécurité multi-repo, une migration de stack complète, une session de pair-programming distribuée. C'est aussi le choix par défaut pour le code qui ne doit jamais toucher votre poste personnel (clients sensibles, conformité, demos).

Tableau comparatif des trois interfaces

Vue d'ensemble des trois interfaces sur les critères qui pèsent au quotidien :

Quand choisir Chat, Terminal ou Cowork

Un arbre de décision rapide, basé sur trois questions simples :

1. Avez-vous besoin que Claude touche vraiment au code ?

• Non (explication, draft, brainstorm) → Chat
• Oui → passer à la question 2

2. La tâche dure-t-elle plus d'une heure ou implique plusieurs personnes ?

• Non (fix court, ajout de feature, review) → Terminal CLI
• Oui (refacto massif, audit, pair-programming) → Cowork

3. Code sensible ou conformité particulière ?

• Si l'environnement local est contraint (DLP, BYOD) → Cowork (sandbox isolé).
• Si rétention zéro requise → vérifier les options entreprise Anthropic.

Exemples concrets

Combiner les trois interfaces dans un workflow

Les trois interfaces ne sont pas concurrentes mais complémentaires. Voici un workflow réaliste que beaucoup d'équipes adoptent — il maximise vitesse et sécurité en confiant chaque étape à l'interface la plus adaptée.

Workflow type sur une nouvelle feature

1. Chat — phase exploration (15 min) : décrire le besoin métier, demander un plan, raffiner l'API publique, valider l'architecture sur Artifacts.
2. Chat — phase ADR (10 min) : Claude rédige un ADR ; vous le copiez dans docs/adr/0042-....
3. Terminal CLI — phase implémentation (1-2 h) : claude dans le repo, plan d'attaque, écriture, tests, commit par étape.
4. Cowork — phase test E2E (overnight) : lancer la suite E2E + audit sécurité sur la branche feature pendant la nuit.
5. Chat — phase review (30 min) : coller le diff dans un Project pour une review indépendante, sans contexte de l'auteur.

Exemple concret de session combinée

# --- 1. Chat (claude.ai) ---
# Prompt : "Voici notre stack (Angular 19 + NestJS + Postgres).
# Je dois ajouter un module 'notifications email'.
# Propose 3 designs avec trade-offs et choisis-en un."

# --- 2. Terminal CLI ---
cd ~/projects/api
git checkout -b feature/email-notifications
claude
# > "Implémente le design retenu : module NotificationsModule,
# > provider EmailProvider basé sur Resend, tests unitaires."

# --- 3. Cowork ---
# Démarrer une session Cowork sur la branche feature/email-notifications
# Prompt long :
# "Lance les tests E2E complets, audit OWASP du nouveau endpoint,
#  benchmark vs MailerSend, propose un PR final"

# --- 4. Chat (review) ---
# Coller le diff final + le PR description dans un nouveau projet
# pour obtenir une review indépendante.

Bonnes pratiques transverses

• Maintenir un CLAUDE.md à jour : les trois interfaces en profitent (la CLI le charge auto, Cowork le clone, le Chat peut le lire via Project).
• Définir des sous-agents partagés dans .claude/agents/ — ils fonctionnent identiquement en CLI et Cowork.
• Versionner les skills personnalisés dans le repo : ils suivent l'équipe.
• Documenter dans le README l'interface recommandée par type de tâche pour aligner l'équipe.

Conclusion

Les trois interfaces de Claude Code couvrent trois besoins différents : le Chat reste l'outil universel pour réfléchir, brainstormer et générer du code à copier ; le Terminal CLI est l'outil de production qui automatise réellement votre cycle dev ; Cowork déplace les tâches longues et collaboratives dans un sandbox cloud, sans bloquer votre machine ni risquer votre filesystem.

Le bon réflexe en équipe n'est pas de choisir une interface unique, mais d'orchestrer les trois : Chat pour cadrer, CLI pour exécuter local, Cowork pour tout ce qui dure ou se partage. Plus vous écrivez un CLAUDE.md propre et plus vous définissez de sous-agents réutilisables, plus ces interfaces deviennent interchangeables sur le code et différentiables sur l'expérience.