Chaque tâche de ce document comprend des instructions claires, des exemples de commandes et les meilleures pratiques pour vous aider à tirer le meilleur parti de Claude Code.

​
Comprendre de nouvelles bases de code

​
Obtenir un aperçu rapide de la base de code

Supposons que vous venez de rejoindre un nouveau projet et que vous devez comprendre sa structure rapidement.
1

Naviguer vers le répertoire racine du projet

cd /path/to/project
2

Démarrer Claude Code

claude
3

Demander un aperçu de haut niveau

> donne-moi un aperçu de cette base de code
4

Approfondir des composants spécifiques

> explique les principaux modèles d'architecture utilisés ici 

> quels sont les modèles de données clés ?

> comment l'authentification est-elle gérée ?
Conseils :
  • Commencez par des questions larges, puis resserrez vers des domaines spécifiques
  • Posez des questions sur les conventions de codage et les modèles utilisés dans le projet
  • Demandez un glossaire des termes spécifiques au projet

​
Trouver du code pertinent

Supposons que vous devez localiser du code lié à une fonctionnalité ou une fonction spécifique.
1

Demander à Claude de trouver les fichiers pertinents

> trouve les fichiers qui gèrent l'authentification des utilisateurs
2

Obtenir le contexte sur la façon dont les composants interagissent

> comment ces fichiers d'authentification fonctionnent-ils ensemble ?
3

Comprendre le flux d'exécution

> trace le processus de connexion du front-end à la base de données
Conseils :
  • Soyez spécifique sur ce que vous recherchez
  • Utilisez le langage du domaine du projet

​
Corriger les bogues efficacement

Supposons que vous avez rencontré un message d’erreur et que vous devez trouver et corriger sa source.
1

Partager l'erreur avec Claude

> je vois une erreur quand j'exécute npm test
2

Demander des recommandations de correction

> suggère quelques façons de corriger le @ts-ignore dans user.ts
3

Appliquer la correction

> mets à jour user.ts pour ajouter la vérification null que tu as suggérée
Conseils :
  • Dites à Claude la commande pour reproduire le problème et obtenir une trace de pile
  • Mentionnez toutes les étapes pour reproduire l’erreur
  • Faites savoir à Claude si l’erreur est intermittente ou constante

​
Refactoriser le code

Supposons que vous devez mettre à jour l’ancien code pour utiliser des modèles et pratiques modernes.
1

Identifier le code hérité pour la refactorisation

> trouve l'utilisation d'API dépréciées dans notre base de code
2

Obtenir des recommandations de refactorisation

> suggère comment refactoriser utils.js pour utiliser les fonctionnalités JavaScript modernes
3

Appliquer les changements en toute sécurité

> refactorise utils.js pour utiliser les fonctionnalités ES2024 tout en maintenant le même comportement
4

Vérifier la refactorisation

> exécute les tests pour le code refactorisé
Conseils :
  • Demandez à Claude d’expliquer les avantages de l’approche moderne
  • Demandez que les changements maintiennent la compatibilité descendante quand nécessaire
  • Faites la refactorisation par petits incréments testables

​
Utiliser des sous-agents spécialisés

Supposons que vous voulez utiliser des sous-agents IA spécialisés pour gérer des tâches spécifiques plus efficacement.
1

Voir les sous-agents disponibles

> /agents
Cela montre tous les sous-agents disponibles et vous permet d’en créer de nouveaux.
2

Utiliser les sous-agents automatiquement

Claude Code délèguera automatiquement les tâches appropriées aux sous-agents spécialisés :
> examine mes changements de code récents pour les problèmes de sécurité

> exécute tous les tests et corrige tous les échecs
3

Demander explicitement des sous-agents spécifiques

> utilise le sous-agent code-reviewer pour vérifier le module auth

> fais en sorte que le sous-agent debugger enquête sur pourquoi les utilisateurs ne peuvent pas se connecter
4

Créer des sous-agents personnalisés pour votre flux de travail

> /agents
Puis sélectionnez “Create New subagent” et suivez les invites pour définir :
  • Type de sous-agent (par ex., api-designer, performance-optimizer)
  • Quand l’utiliser
  • Quels outils il peut accéder
  • Son invite système spécialisée
Conseils :
  • Créez des sous-agents spécifiques au projet dans .claude/agents/ pour le partage d’équipe
  • Utilisez des champs description descriptifs pour permettre la délégation automatique
  • Limitez l’accès aux outils à ce dont chaque sous-agent a réellement besoin
  • Consultez la documentation des sous-agents pour des exemples détaillés

​
Utiliser le Mode Plan pour l’analyse de code sécurisée

Le Mode Plan instruit Claude de créer un plan en analysant la base de code avec des opérations en lecture seule, parfait pour explorer les bases de code, planifier des changements complexes, ou réviser le code en toute sécurité.

​
Quand utiliser le Mode Plan

  • Implémentation multi-étapes : Quand votre fonctionnalité nécessite de faire des modifications à de nombreux fichiers
  • Exploration de code : Quand vous voulez rechercher la base de code minutieusement avant de changer quoi que ce soit
  • Développement interactif : Quand vous voulez itérer sur la direction avec Claude

​
Comment utiliser le Mode Plan

Activer le Mode Plan pendant une session Vous pouvez basculer en Mode Plan pendant une session en utilisant Shift+Tab pour parcourir les modes de permission. Si vous êtes en Mode Normal, Shift+Tab basculera d’abord en Mode Auto-Accept, indiqué par ⏵⏵ accept edits on en bas du terminal. Un Shift+Tab subséquent basculera en Mode Plan, indiqué par ⏸ plan mode on. Démarrer une nouvelle session en Mode Plan Pour démarrer une nouvelle session en Mode Plan, utilisez le flag --permission-mode plan : 
claude --permission-mode plan
Exécuter des requêtes “headless” en Mode Plan Vous pouvez aussi exécuter une requête en Mode Plan directement avec -p (c’est-à-dire en “mode headless”) : 
claude --permission-mode plan -p "Analyse le système d'authentification et suggère des améliorations"

​
Exemple : Planifier une refactorisation complexe

claude --permission-mode plan

> J'ai besoin de refactoriser notre système d'authentification pour utiliser OAuth2. Crée un plan de migration détaillé.
Claude analysera l’implémentation actuelle et créera un plan complet. Affinez avec des suivis : 
> Qu'en est-il de la compatibilité descendante ?
> Comment devrions-nous gérer la migration de base de données ?

​
Configurer le Mode Plan par défaut

// .claude/settings.json
{
  "permissions": {
    "defaultMode": "plan"
  }
}
Voir la documentation des paramètres pour plus d’options de configuration.

​
Travailler avec les tests

Supposons que vous devez ajouter des tests pour du code non couvert.
1

Identifier le code non testé

> trouve les fonctions dans NotificationsService.swift qui ne sont pas couvertes par les tests
2

Générer l'échafaudage de test

> ajoute des tests pour le service de notification
3

Ajouter des cas de test significatifs

> ajoute des cas de test pour les conditions limites dans le service de notification
4

Exécuter et vérifier les tests

> exécute les nouveaux tests et corrige tous les échecs
Conseils :
  • Demandez des tests qui couvrent les cas limites et les conditions d’erreur
  • Demandez à la fois des tests unitaires et d’intégration quand approprié
  • Faites expliquer la stratégie de test par Claude

​
Créer des pull requests

Supposons que vous devez créer une pull request bien documentée pour vos changements.
1

Résumer vos changements

> résume les changements que j'ai apportés au module d'authentification
2

Générer une PR avec Claude

> crée une pr
3

Réviser et affiner

> améliore la description de la PR avec plus de contexte sur les améliorations de sécurité
4

Ajouter des détails de test

> ajoute des informations sur comment ces changements ont été testés
Conseils :
  • Demandez directement à Claude de faire une PR pour vous
  • Révisez la PR générée par Claude avant de la soumettre
  • Demandez à Claude de souligner les risques potentiels ou les considérations

​
Gérer la documentation

Supposons que vous devez ajouter ou mettre à jour la documentation pour votre code.
1

Identifier le code non documenté

> trouve les fonctions sans commentaires JSDoc appropriés dans le module auth
2

Générer la documentation

> ajoute des commentaires JSDoc aux fonctions non documentées dans auth.js
3

Réviser et améliorer

> améliore la documentation générée avec plus de contexte et d'exemples
4

Vérifier la documentation

> vérifie si la documentation suit nos standards de projet
Conseils :
  • Spécifiez le style de documentation que vous voulez (JSDoc, docstrings, etc.)
  • Demandez des exemples dans la documentation
  • Demandez de la documentation pour les API publiques, interfaces, et logique complexe

​
Travailler avec les images

Supposons que vous devez travailler avec des images dans votre base de code, et vous voulez l’aide de Claude pour analyser le contenu des images.
1

Ajouter une image à la conversation

Vous pouvez utiliser n’importe laquelle de ces méthodes :
  1. Glisser-déposer une image dans la fenêtre Claude Code
  2. Copier une image et la coller dans le CLI avec ctrl+v (N’utilisez pas cmd+v)
  3. Fournir un chemin d’image à Claude. Par ex., “Analyse cette image : /path/to/your/image.png”
2

Demander à Claude d'analyser l'image

> Que montre cette image ?

> Décris les éléments d'interface utilisateur dans cette capture d'écran

> Y a-t-il des éléments problématiques dans ce diagramme ?
3

Utiliser les images pour le contexte

> Voici une capture d'écran de l'erreur. Qu'est-ce qui la cause ?

> Ceci est notre schéma de base de données actuel. Comment devrions-nous le modifier pour la nouvelle fonctionnalité ?
4

Obtenir des suggestions de code à partir du contenu visuel

> Génère du CSS pour correspondre à cette maquette de design

> Quelle structure HTML recréerait ce composant ?
Conseils :
  • Utilisez des images quand les descriptions textuelles seraient peu claires ou encombrantes
  • Incluez des captures d’écran d’erreurs, de designs d’interface utilisateur, ou de diagrammes pour un meilleur contexte
  • Vous pouvez travailler avec plusieurs images dans une conversation
  • L’analyse d’image fonctionne avec les diagrammes, captures d’écran, maquettes, et plus

​
Référencer des fichiers et répertoires

Utilisez @ pour inclure rapidement des fichiers ou répertoires sans attendre que Claude les lise.
1

Référencer un seul fichier

> Explique la logique dans @src/utils/auth.js
Cela inclut le contenu complet du fichier dans la conversation.
2

Référencer un répertoire

> Quelle est la structure de @src/components ?
Cela fournit une liste de répertoire avec les informations de fichier.
3

Référencer les ressources MCP

> Montre-moi les données de @github:repos/owner/repo/issues
Cela récupère les données des serveurs MCP connectés en utilisant le format @server:resource. Voir ressources MCP pour les détails.
Conseils :
  • Les chemins de fichier peuvent être relatifs ou absolus
  • Les références de fichier @ ajoutent CLAUDE.md dans le répertoire du fichier et les répertoires parents au contexte
  • Les références de répertoire montrent les listes de fichiers, pas les contenus
  • Vous pouvez référencer plusieurs fichiers dans un seul message (par ex., “@file1.js et @file2.js”)

​
Utiliser la réflexion étendue

Supposons que vous travaillez sur des décisions architecturales complexes, des bogues difficiles, ou la planification d’implémentations multi-étapes qui nécessitent un raisonnement profond.
La réflexion étendue est désactivée par défaut dans Claude Code. Vous pouvez l’activer à la demande en utilisant Tab pour basculer Thinking on, ou en utilisant des invites comme “think” ou “think hard”. Vous pouvez aussi l’activer de façon permanente en définissant la variable d’environnement MAX_THINKING_TOKENS dans vos paramètres.
1

Fournir le contexte et demander à Claude de réfléchir

> J'ai besoin d'implémenter un nouveau système d'authentification utilisant OAuth2 pour notre API. Réfléchis profondément à la meilleure approche pour implémenter cela dans notre base de code.
Claude rassemblera les informations pertinentes de votre base de code et utilisera la réflexion étendue, qui sera visible dans l’interface.
2

Affiner la réflexion avec des invites de suivi

> réfléchis aux vulnérabilités de sécurité potentielles dans cette approche 

> réfléchis intensément aux cas limites que nous devrions gérer
Conseils pour tirer le maximum de valeur de la réflexion étendue :La réflexion étendue est plus précieuse pour les tâches complexes telles que :
  • Planifier des changements architecturaux complexes
  • Déboguer des problèmes complexes
  • Créer des plans d’implémentation pour de nouvelles fonctionnalités
  • Comprendre des bases de code complexes
  • Évaluer les compromis entre différentes approches
Utilisez Tab pour basculer Thinking on et off pendant une session.La façon dont vous invitez à la réflexion résulte en différents niveaux de profondeur de réflexion :
  • “think” déclenche la réflexion étendue de base
  • les phrases intensifiantes telles que “keep hard”, “think more”, “think a lot”, ou “think longer” déclenchent une réflexion plus profonde
Pour plus de conseils d’invitation à la réflexion étendue, voir Conseils de réflexion étendue.
Claude affichera son processus de réflexion comme du texte gris italique au-dessus de la réponse.

​
Reprendre les conversations précédentes

Supposons que vous avez travaillé sur une tâche avec Claude Code et que vous devez continuer où vous vous êtes arrêté dans une session ultérieure. Claude Code fournit deux options pour reprendre les conversations précédentes :
  • --continue pour continuer automatiquement la conversation la plus récente
  • --resume pour afficher un sélecteur de conversation
1

Continuer la conversation la plus récente

claude --continue
Cela reprend immédiatement votre conversation la plus récente sans aucune invite.
2

Continuer en mode non-interactif

claude --continue --print "Continue avec ma tâche"
Utilisez --print avec --continue pour reprendre la conversation la plus récente en mode non-interactif, parfait pour les scripts ou l’automatisation.
3

Afficher le sélecteur de conversation

claude --resume
Cela affiche un sélecteur de conversation interactif avec une vue de liste propre montrant :
  • Résumé de session (ou invite initiale)
  • Métadonnées : temps écoulé, nombre de messages, et branche git
Utilisez les touches fléchées pour naviguer et appuyez sur Entrée pour sélectionner une conversation. Appuyez sur Échap pour sortir.
Conseils :
  • L’historique des conversations est stocké localement sur votre machine
  • Utilisez --continue pour un accès rapide à votre conversation la plus récente
  • Utilisez --resume quand vous devez sélectionner une conversation passée spécifique
  • Lors de la reprise, vous verrez tout l’historique de conversation avant de continuer
  • La conversation reprise commence avec le même modèle et configuration que l’original
Comment ça fonctionne :
  1. Stockage de Conversation : Toutes les conversations sont automatiquement sauvegardées localement avec leur historique de message complet
  2. Désérialisation de Message : Lors de la reprise, tout l’historique de message est restauré pour maintenir le contexte
  3. État d’Outil : L’utilisation d’outil et les résultats de la conversation précédente sont préservés
  4. Restauration de Contexte : La conversation reprend avec tout le contexte précédent intact
Exemples :
# Continuer la conversation la plus récente
claude --continue

# Continuer la conversation la plus récente avec une invite spécifique
claude --continue --print "Montre-moi notre progrès"

# Afficher le sélecteur de conversation
claude --resume

# Continuer la conversation la plus récente en mode non-interactif
claude --continue --print "Exécute les tests à nouveau"

​
Exécuter des sessions Claude Code parall`eles avec les arbres de travail Git

Supposons que vous devez travailler sur plusieurs tâches simultanément avec une isolation de code complète entre les instances Claude Code.
1

Comprendre les arbres de travail Git

Les arbres de travail Git vous permettent de vérifier plusieurs branches du même dépôt dans des répertoires séparés. Chaque arbre de travail a son propre répertoire de travail avec des fichiers isolés, tout en partageant la même histoire Git. Apprenez-en plus dans la documentation officielle des arbres de travail Git.
2

Créer un nouvel arbre de travail

# Créer un nouvel arbre de travail avec une nouvelle branche 
git worktree add ../project-feature-a -b feature-a

# Ou créer un arbre de travail avec une branche existante
git worktree add ../project-bugfix bugfix-123
Cela crée un nouveau répertoire avec une copie de travail séparée de votre dépôt.
3

Exécuter Claude Code dans chaque arbre de travail

# Naviguer vers votre arbre de travail 
cd ../project-feature-a

# Exécuter Claude Code dans cet environnement isolé
claude
4

Exécuter Claude dans un autre arbre de travail

cd ../project-bugfix
claude
5

Gérer vos arbres de travail

# Lister tous les arbres de travail
git worktree list

# Supprimer un arbre de travail quand terminé
git worktree remove ../project-feature-a
Conseils :
  • Chaque arbre de travail a son propre état de fichier indépendant, le rendant parfait pour les sessions Claude Code parallèles
  • Les changements faits dans un arbre de travail n’affecteront pas les autres, empêchant les instances Claude d’interférer les unes avec les autres
  • Tous les arbres de travail partagent la même histoire Git et les connexions distantes
  • Pour les tâches de longue durée, vous pouvez avoir Claude travaillant dans un arbre de travail pendant que vous continuez le développement dans un autre
  • Utilisez des noms de répertoire descriptifs pour identifier facilement quelle tâche chaque arbre de travail est pour
  • Rappelez-vous d’initialiser votre environnement de développement dans chaque nouvel arbre de travail selon la configuration de votre projet. Selon votre pile, cela pourrait inclure :
    • Projets JavaScript : Exécuter l’installation de dépendances (npm install, yarn)
    • Projets Python : Configurer des environnements virtuels ou installer avec des gestionnaires de paquets
    • Autres langages : Suivre le processus de configuration standard de votre projet

​
Utiliser Claude comme un utilitaire de style unix

​
Ajouter Claude à votre processus de vérification

Supposons que vous voulez utiliser Claude Code comme un linter ou réviseur de code. Ajouter Claude à votre script de build : 
// package.json
{
    ...
    "scripts": {
        ...
        "lint:claude": "claude -p 'tu es un linter. s'il te plaît regarde les changements vs. main et rapporte tous les problèmes liés aux fautes de frappe. rapporte le nom de fichier et le numéro de ligne sur une ligne, et une description du problème sur la deuxième ligne. ne retourne aucun autre texte.'"
    }
}
Conseils :
  • Utilisez Claude pour la révision de code automatisée dans votre pipeline CI/CD
  • Personnalisez l’invite pour vérifier des problèmes spécifiques pertinents à votre projet
  • Considérez créer plusieurs scripts pour différents types de vérification

​
Pipe in, pipe out

Supposons que vous voulez envoyer des données à Claude par pipe, et récupérer des données dans un format structuré. Envoyer des données par pipe à travers Claude : 
cat build-error.txt | claude -p 'explique de façon concise la cause racine de cette erreur de build' > output.txt
Conseils :
  • Utilisez des pipes pour intégrer Claude dans les scripts shell existants
  • Combinez avec d’autres outils Unix pour des flux de travail puissants
  • Considérez utiliser —output-format pour une sortie structurée

​
Contrôler le format de sortie

Supposons que vous avez besoin de la sortie de Claude dans un format spécifique, surtout lors de l’intégration de Claude Code dans des scripts ou autres outils.
1

Utiliser le format texte (par défaut)

cat data.txt | claude -p 'résume ces données' --output-format text > summary.txt
Cela sort juste la réponse en texte brut de Claude (comportement par défaut).
2

Utiliser le format JSON

cat code.py | claude -p 'analyse ce code pour les bogues' --output-format json > analysis.json
Cela sort un tableau JSON de messages avec des métadonnées incluant le coût et la durée.
3

Utiliser le format JSON en streaming

cat log.txt | claude -p 'analyse ce fichier de log pour les erreurs' --output-format stream-json
Cela sort une série d’objets JSON en temps réel pendant que Claude traite la requête. Chaque message est un objet JSON valide, mais la sortie entière n’est pas du JSON valide si concaténée.
Conseils :
  • Utilisez --output-format text pour des intégrations simples où vous avez juste besoin de la réponse de Claude
  • Utilisez --output-format json quand vous avez besoin du log de conversation complet
  • Utilisez --output-format stream-json pour une sortie en temps réel de chaque tour de conversation

​
Créer des commandes slash personnalisées

Claude Code supporte les commandes slash personnalisées que vous pouvez créer pour exécuter rapidement des invites ou tâches spécifiques. Pour plus de détails, voir la page de référence Commandes slash.

​
Créer des commandes spécifiques au projet

Supposons que vous voulez créer des commandes slash réutilisables pour votre projet que tous les membres de l’équipe peuvent utiliser.
1

Créer un répertoire de commandes dans votre projet

mkdir -p .claude/commands
2

Créer un fichier Markdown pour chaque commande

echo "Analyse la performance de ce code et suggère trois optimisations spécifiques :" > .claude/commands/optimize.md
3

Utiliser votre commande personnalisée dans Claude Code

> /optimize
Conseils :
  • Les noms de commande sont dérivés du nom de fichier (par ex., optimize.md devient /optimize)
  • Vous pouvez organiser les commandes dans des sous-répertoires (par ex., .claude/commands/frontend/component.md crée /component avec “(project:frontend)” affiché dans la description)
  • Les commandes de projet sont disponibles à tous ceux qui clonent le dépôt
  • Le contenu du fichier Markdown devient l’invite envoyée à Claude quand la commande est invoquée

​
Ajouter des arguments de commande avec $ARGUMENTS

Supposons que vous voulez créer des commandes slash flexibles qui peuvent accepter une entrée supplémentaire des utilisateurs.
1

Créer un fichier de commande avec le placeholder $ARGUMENTS

echo 'Trouve et corrige le problème #$ARGUMENTS. Suis ces étapes : 1.
Comprends le problème décrit dans le ticket 2. Localise le code pertinent dans
notre base de code 3. Implémente une solution qui adresse la cause racine 4. Ajoute
des tests appropriés 5. Prépare une description de PR concise' >
.claude/commands/fix-issue.md
2

Utiliser la commande avec un numéro de problème

Dans votre session Claude, utilisez la commande avec des arguments.
> /fix-issue 123
Cela remplacera $ARGUMENTS par “123” dans l’invite.
Conseils :
  • Le placeholder $ARGUMENTS est remplacé par tout texte qui suit la commande
  • Vous pouvez positionner $ARGUMENTS n’importe où dans votre modèle de commande
  • Autres applications utiles : générer des cas de test pour des fonctions spécifiques, créer de la documentation pour des composants, réviser du code dans des fichiers particuliers, ou traduire du contenu vers des langues spécifiées

​
Créer des commandes slash personnelles

Supposons que vous voulez créer des commandes slash personnelles qui fonctionnent à travers tous vos projets.
1

Créer un répertoire de commandes dans votre dossier home

mkdir -p ~/.claude/commands
2

Créer un fichier Markdown pour chaque commande

echo "Révise ce code pour les vulnérabilités de sécurité, en se concentrant sur :" >
~/.claude/commands/security-review.md
3

Utiliser votre commande personnalisée

> /security-review
Conseils :
  • Les commandes personnelles montrent “(user)” dans leur description quand listées avec /help
  • Les commandes personnelles ne sont disponibles qu’à vous et ne sont pas partagées avec votre équipe
  • Les commandes personnelles fonctionnent à travers tous vos projets
  • Vous pouvez les utiliser pour des flux de travail cohérents à travers différentes bases de code

​
Demander à Claude ses capacités

Claude a un accès intégré à sa documentation et peut répondre aux questions sur ses propres fonctionnalités et limitations.

​
Exemples de questions

> Claude Code peut-il créer des pull requests ?

> comment Claude Code gère-t-il les permissions ?

> quelles commandes slash sont disponibles ?

> comment utiliser MCP avec Claude Code ?

> comment configurer Claude Code pour Amazon Bedrock ?

> quelles sont les limitations de Claude Code ?
Claude fournit des réponses basées sur la documentation à ces questions. Pour des exemples exécutables et des démonstrations pratiques, référez-vous aux sections de flux de travail spécifiques ci-dessus.
Conseils :
  • Claude a toujours accès à la dernière documentation Claude Code, peu importe la version que vous utilisez
  • Posez des questions spécifiques pour obtenir des réponses détaillées
  • Claude peut expliquer des fonctionnalités complexes comme l’intégration MCP, les configurations d’entreprise, et les flux de travail avancés

​
Prochaines étapes

Implémentation de référence Claude Code

Clonez notre implémentation de référence de conteneur de développement.