Chaque tâche de ce document comprend des instructions claires, des exemples de commandes et des 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 si nécessaire
  • Faites la refactorisation par petits incréments testables

​
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 c’est approprié
  • Demandez à Claude d’expliquer la stratégie de test

​
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 la façon dont 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, les interfaces et la 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 exemple, “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 ?

> Voici 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’images fonctionne avec des diagrammes, des captures d’écran, des maquettes et plus

​
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 approfondi.

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 plus 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

La façon dont vous demandez la réflexion résulte en différents niveaux de profondeur de réflexion :

  • “réfléchis” déclenche une réflexion étendue de base
  • les phrases d’intensification telles que “réfléchis plus”, “réfléchis beaucoup”, “réfléchis plus intensément”, ou “réfléchis plus longtemps” déclenchent une réflexion plus profonde

Pour plus de conseils sur les invites de réflexion étendue, voir Conseils de réflexion étendue.

Claude affichera son processus de réflexion sous forme de texte gris en 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 là 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 montrant :

  • L’heure de début de la conversation
  • L’invite initiale ou le résumé de la conversation
  • Le nombre de messages

Utilisez les touches fléchées pour naviguer et appuyez sur Entrée pour sélectionner une conversation.

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 la conversation avant de continuer
  • La conversation reprise commence avec le même modèle et la même configuration que l’original

Comment cela fonctionne :

  1. Stockage des conversations : Toutes les conversations sont automatiquement sauvegardées localement avec leur historique complet de messages
  2. Désérialisation des messages : Lors de la reprise, tout l’historique des messages est restauré pour maintenir le contexte
  3. État des outils : L’utilisation des outils et les résultats de la conversation précédente sont préservés
  4. Restauration du 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 nos 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èles avec les arbres de travail Git

Supposons que vous devez travailler sur plusieurs tâches simultanément avec une isolation complète du code 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 le même historique 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 c'est terminé
git worktree remove ../project-feature-a

Conseils :

  • Chaque arbre de travail a son propre état de fichier indépendant, ce qui le rend parfait pour les sessions Claude Code parallèles
  • Les changements effectués 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 le même historique Git et les mêmes connexions distantes
  • Pour les tâches de longue durée, vous pouvez avoir Claude qui travaille 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 représente
  • N’oubliez pas 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 des 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 un 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 par rapport à main et signale tous les problèmes liés aux fautes de frappe. signale 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 automatisée de code 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 d’entrée, pipe de sortie

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 manière 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 d’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 demande. 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 journal 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 prend en charge les commandes slash personnalisées que vous pouvez créer pour exécuter rapidement des invites ou des 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 les performances de ce code et suggère trois optimisations spécifiques :" > .claude/commands/optimize.md
3

Utiliser votre commande personnalisée dans Claude Code

> /project:optimize

Conseils :

  • Les noms de commande sont dérivés du nom de fichier (par exemple, optimize.md devient /project:optimize)
  • Vous pouvez organiser les commandes dans des sous-répertoires (par exemple, .claude/commands/frontend/component.md devient /project:frontend:component)
  • Les commandes de projet sont disponibles pour 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 des entrées supplémentaires des utilisateurs.

1

Créer un fichier de commande avec l'espace réservé $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.

> /project:fix-issue 123

Cela remplacera $ARGUMENTS par “123” dans l’invite.

Conseils :

  • L’espace réservé $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 dans tous vos projets.

1

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

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 personnelle

> /user:security-review

Conseils :

  • Les commandes personnelles sont préfixées avec /user: au lieu de /project:
  • Les commandes personnelles ne sont disponibles que pour vous et ne sont pas partagées avec votre équipe
  • Les commandes personnelles fonctionnent dans tous vos projets
  • Vous pouvez les utiliser pour des flux de travail cohérents dans différentes bases de code

​
Prochaines étapes

Implémentation de référence Claude Code

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