Claude Code Cheat Sheet : Le Guide Complet pour Développeurs Débutants

Si vous vous plongez dans **Claude Code**, l'assistant de codage puissant basé sur l'IA d'Anthropic, disposer d'une référence claire est essentiel. Ce **Cheatsheet Claude Code** est destiné aux développeurs qui souhaitent un guide pratique et convivial pour les débutants, couvrant la configuration, les flux de travail, la configuration et les conseils avancés. À la fin, vous vous sentirez plus confiant pour utiliser Claude Code dans votre environnement local ou dans le cadre de vos processus CI/CD.

Qu'est-ce que Claude Code ?

Claude Code est un outil de codage IA basé sur la CLI (interface de ligne de commande) développé par Anthropic. Il permet aux développeurs de générer, refactoriser, tester et documenter du code en utilisant les modèles avancés de Claude. Plutôt qu'une simple interface de chat, Claude Code se comporte comme un IDE IA : il comprend la structure de votre dépôt, applique des garde-fous définis dans les fichiers de configuration, peut exécuter des commandes bash et s'intègre aux flux de travail Git.

Installer Claude Code :

# MacOS/Linux:
curl -fsSL https://claude.ai/install.sh | bash

# Windows:
irm https://claude.ai/install.ps1 | iex

# NPM:
npm install -g @anthropic-ai/claude-code

# Homebrew:
brew install --cask claude-code

Commencer à utiliser Claude Code :

cd your-project
claude

bouton

Composants clés de Claude Code — Votre aide-mémoire

Voici les éléments constitutifs et les fonctionnalités essentiels que vous voudrez connaître pour commencer avec Claude Code :

1. CLAUDE.md — Manifeste de l'agent

• Le fichier CLAUDE.md est la « constitution » de votre agent : il définit comment Claude se comporte dans votre dépôt.
• Utilisez-le pour documenter les outils approuvés, les flux de travail courants et les contraintes.
• Bonne pratique : Gardez-le court, concentré sur les garde-fous clés, et évitez d'intégrer de très grands documents.

# MyProject CLAUDE.md

## Project Overview  
This is a Node.js + Express REST API for a task management application.  

## Technology Stack  
- Backend: Node.js (ES6), Express  
- Database: PostgreSQL  
- Testing: Jest  
- Linting & Style: ESLint, Prettier

## Development Commands  
- `npm install` — Install dependencies  
- `npm run dev` — Start development server  
- `npm run test` — Run all tests  
- `npm run lint` — Run linter  

## Coding Standards  
- Use 2-space indentation.  
- Always use `async / await` instead of `.then()` chains.  
- Functions must have JSDoc comments.  
- Prefer composition over inheritance.

## Git Workflow  
- Feature branches must follow this pattern: `feature/FOO`  
- Use `git rebase` instead of `merge` for updating branches.  
- When committing: write descriptive commit messages that follow the Conventional Commits format.

## File Structure Guidance  
- `src/` — Your main application code  
- `tests/` — Test files  
- `scripts/` — Utility or setup scripts  
- `migrations/` — Database migrations  

## Known Issues / Workarounds  
- `db.connect()` sometimes times out; in that case, retry twice.  
- For large JSON payloads, use streaming to avoid memory issues.

## Memory / Style Preferences  
- Always ask for clarification if the request is ambiguous.  
- Do not generate new `.md` files unless explicitly instructed.  
- Include a `co-authored-by Claude` line in generated commits.

2. Gestion du contexte

a. Utilisez **/context** pour inspecter l'utilisation des jetons de votre session Claude actuelle.

b. Commandes pour redémarrer ou réduire le contexte :

• /clear + /catchup : Efface toute la conversation, puis recharge les fichiers depuis un commit ou une branche.
• Un flux « Documenter et Effacer » : demandez à Claude de sauvegarder son plan dans un fichier Markdown, d'effacer la mémoire, puis de recharger à partir de ce fichier.

3. Commandes slash

• Les commandes slash sont des raccourcis vers des invites prédéfinies.
• Exemples :

• Gardez les commandes slash minimales et ciblées ; ne vous fiez pas à elles pour chaque tâche.

4. Mode Planification

• Utilisez le mode planification lorsque vous débutez des tâches complexes. Claude esquissera un plan avant d'écrire le code.
• Vous pouvez ensuite examiner, modifier ou approuver ce plan avant de demander à Claude de l'exécuter.
• Idéal pour les gros travaux de fonctionnalités, le refactoring ou les changements architecturaux.

5. Sous-agents et Délégation de tâches

• Claude Code prend en charge les **sous-agents**, vous permettant de déléguer des parties du travail à des « clones » de l'agent principal.
• Shrivu préfère une architecture « Maître-Clone » : l'agent principal génère des clones via `Task(...)`, plutôt que d'utiliser des sous-agents spécialisés et rigides.
• Cela préserve la flexibilité tout en évitant la fragmentation du contexte.
• Accédez aux sous-agents de Claude Code en utilisant la commande slash : /agents.

6. Compétences Claude vs. MCP — Quelle est la différence ?

a. Les **Compétences Claude** sont des « modules » pré-construits qui enseignent à Claude *comment* effectuer des tâches spécifiques. Elles sont écrites en Markdown ou en code, et ne sont chargées qu'en cas de besoin. Vous pouvez utiliser les Compétences pour définir des flux de travail comme la mise en forme de rapports, la synthèse de données ou l'application du style de votre équipe.

b. Le **Model Context Protocol (MCP)**, quant à lui, est un protocole pour connecter Claude à des données et des outils externes — tels que des bases de données, votre base de code ou des systèmes d'entreprise. C'est comme un « adaptateur universel » qui permet à Claude d'accéder et d'agir sur des ressources externes sans intégrations personnalisées par outil.

c. Différences clés :

1. Objectif :

• Les Compétences encodent des *connaissances procédurales*.
• Le MCP gère la *connectivité des outils et des données*.

2. Efficacité des jetons :

• Les Compétences ne sont chargées qu'en cas de besoin, utilisant relativement peu de jetons.
• Les définitions d'outils MCP peuvent occuper un espace de jetons significatif si de nombreuses sont activées.

d. Cas d'utilisation :

• Utilisez les **Compétences** pour enseigner à Claude des flux de travail spécifiques à un domaine (par exemple, « lors de la rédaction de rapports d'état, incluez toujours X, Y, Z »).
• Utilisez le **MCP** lorsque Claude a besoin de *lire/écrire des données*, d'appeler des API ou d'accéder à des systèmes externes comme Git ou une base de données.

En pratique, les deux fonctionnent mieux ensemble : le **MCP** donne à Claude accès à vos données, et les **Compétences** enseignent à Claude comment utiliser ces données de manière structurée et répétable.

6. Hooks (Crochets)

a. Les Hooks sont votre moyen d'appliquer des règles automatiquement.

b. Deux types courants :

• **Blocage à la soumission** : Par exemple, un hook `PreToolUse` peut bloquer `git commit` à moins que les tests n'aient réussi.
• **Hooks d'indication** : Non bloquants ; ils fournissent des conseils ou des suggestions sans arrêter l'exécution.

c. Évitez les hooks de « blocage à l'écriture » — laisser Claude terminer son plan puis valider est plus stable.

# Example Hook in .claude/settings.toml

[[hooks]]
# The event that triggers the hook.
event = "PostToolUse" 

# (Optional) Conditions for the hook to run.
[hooks.matcher]
tool_name = "edit_file"
file_paths = ["*.py", "api/**/*.py"]

# The shell command to execute.
command = "ruff check --fix $CLAUDE_FILE_PATHS && black $CLAUDE_FILE_PATHS"

# (Optional) Whether to run the command in the background.
run_in_background = false 

7. SDK CLI

• Le **SDK Claude Code** vous permet de scripter les interactions de Claude : utile pour le traitement par lots, la création d'outils internes ou le prototypage d'agents.
• Utilisez-le pour exécuter des refactorisations parallèles, générer du code à partir de modèles, ou comme agent léger au sein des flux de travail CI/CD.

Installation :

# Typescript:
npm install @anthropic-ai/claude-agent-sdk

# Python:
pip install claude-agent-sdk

8. Actions GitHub Claude Code (GHA)

• Vous pouvez intégrer Claude Code directement dans les Actions GitHub.
• Utilisez-le pour générer automatiquement des pull requests, appliquer des standards de code, ou exécuter des vérifications basées sur CLAUDE.md dans le cadre de votre pipeline CI.
• Puisque les journaux sont stockés, vous pouvez auditer le comportement de l'agent et améliorer votre fichier CLAUDE.md au fil du temps.

9. Paramètres et Configuration

a. Dans `settings.json`, vous pouvez configurer :

• Proxy (`HTTPS_PROXY`) — utile pour le débogage du trafic CLI.
• Délais d'attente (`MCP_TOOL_TIMEOUT`, `BASH_MAX_TIMEOUT_MS`) — augmentez-les si vous exécutez des tâches longues.
• Clé API (`ANTHROPIC_API_KEY`) — utilisez votre clé d'Anthropic ou un script d'aide.
• Permissions — contrôlez quels outils système Claude Code est autorisé à exécuter.

{
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test:*)",
      "Read(~/.zshrc)"
    ],
    "deny": [
      "Bash(curl:*)",
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)"
    ]
  },
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp"
  },
  "companyAnnouncements": [
    "Bienvenue chez Acme Corp ! Consultez nos directives de code sur docs.acme.com",
    "Rappel : Les revues de code sont requises pour toutes les PR",
    "Nouvelle politique de sécurité en vigueur"
  ]
}

Fonctionnalités avancées et astuces de productivité

1. Changement de modèle : Choisissez Claude 4 Sonnet ou Opus en fonction de votre tâche. Sonnet est rapide et rentable ; Opus est plus performant pour les changements complexes impliquant plusieurs fichiers.
2. Modes de pensée (Triche) : Certains utilisateurs règlent le mode de raisonnement de Claude sur `think`, `think hard`, `think harder`, ou `ultrathink` pour ajuster la profondeur de son raisonnement.
3. Commandes personnalisées : Définissez des commandes slash réutilisables dans `.claude/commands` avec des espaces réservés dynamiques (`$argument`). Idéal pour les tests, la construction ou la révision.
4. Historique des sessions : Utilisez `claude --resume` ou `claude --continue` pour reprendre d'anciennes sessions. Claude stocke tout l'historique des sessions localement.
5. Boucle de rétroaction : Examinez le comportement de l'agent via les journaux des Actions GitHub ou les données de session historiques et mettez à jour votre `CLAUDE.md` pour corriger les malentendus ou appliquer de meilleurs garde-fous.

Foire Aux Questions (FAQ)

Q1. Quel est l'objectif de `CLAUDE.md` ?
Rép: `CLAUDE.md` sert de manifeste à l'agent. Il définit les règles, les outils et les conventions que Claude Code doit suivre. Il aide à standardiser le comportement dans votre dépôt.

Q2. Dois-je utiliser des sous-agents ou de simples tâches ?
Rép: Utilisez des sous-agents si vous souhaitez des flux de travail modulaires stricts. Mais beaucoup trouvent le modèle **Maître-Clone** (utilisant `Task(...)`) plus flexible — vous conservez le contexte tout en déléguant des sous-tâches.

Q3. Comment redémarrer une session Claude sans tout perdre ?
Rép: Utilisez `/clear` pour réinitialiser le chat, puis `/catchup` pour charger les fichiers de votre branche Git afin que Claude retrouve son contexte complet.

Q4. Que sont les hooks, et pourquoi en ai-je besoin ?
Rép: Les hooks appliquent des règles ou des vérifications lorsque Claude valide du travail. Par exemple, un hook de blocage à la soumission peut garantir que les tests réussissent avant qu'un commit Git ne soit autorisé.

Q5. Comment puis-je intégrer Claude Code dans la CI/CD ?
Rép: Utilisez l'Action GitHub Claude Code pour exécuter des tâches, valider du code, générer des pull requests ou appliquer vos garde-fous `CLAUDE.md` dans des pipelines automatisés.

Conclusion

Ce **Cheatsheet Claude Code** vous offre un aperçu pratique et structuré de l'utilisation efficace de Claude Code. De la rédaction d'un fichier `CLAUDE.md` bien conçu à l'exploitation des commandes slash, des sous-agents, des hooks et de l'intégration CI — ces modèles constituent une base solide pour utiliser Claude Code comme un partenaire de développement fiable, alimenté par l'IA.

En maîtrisant ces fonctionnalités, les nouveaux développeurs peuvent s'intégrer rapidement, et les ingénieurs plus expérimentés peuvent rationaliser leurs flux de travail, appliquer des garde-fous et augmenter la productivité assistée par Claude. Claude Code est plus qu'un simple outil de génération de code — c'est un système agentique programmable qui s'adapte aux besoins de votre équipe.

bouton