50 façons pratiques d'utiliser Claude Code : recettes pour déléguer vos tâches quotidiennes

Claude Code est un outil qui vous permet de déléguer du travail à Claude directement depuis votre terminal. Il ne sert pas uniquement à écrire du code ; il peut gérer tout, de l'organisation de fichiers et du traitement de données à la recherche et à la création de documents, en prenant en charge vos tâches quotidiennes fastidieuses. Cet article résume 50 tâches spécifiques pour lesquelles vous pouvez immédiatement en voir la valeur, organisées par Scénario → Méthode (instructions que vous pouvez taper telles quelles) → Effet. Essayez celles qui vous intéressent dès aujourd'hui.

Table des matières

1. Automatisation de l'organisation des fichiers et dossiers (01–05)
2. Traitement et conversion de données (06–10)
3. Écriture et correction de code (11–18)
4. Compréhension des bases de code (19–23)
5. Délégation de tâches Git/GitHub (24–29)
6. Configuration de l'environnement, scripts et paramétrage (30–34)
7. Recherche et création de documents (35–39)
8. Optimisation de l'efficacité (Paramètres et automatisation) (40–45)
9. Intégrations, images et techniques de flux de travail (46–50)

1. Automatisation de l'organisation des fichiers et dossiers

Claude Code excelle dans les opérations sur les fichiers. Vous pouvez lui demander de nettoyer des environnements encombrés en une seule fois.

01. Classer automatiquement les téléchargements par projet ou type

• Scénario : Le dossier Téléchargements est un vrai fouillis, vous ne trouvez plus vos fichiers.
• Méthode : « Regarde le contenu de Téléchargements et organise-le dans des dossiers par projet et par type de fichier. »
• Effet : Le tri de centaines de fichiers est terminé en quelques minutes. Fini le rangement manuel.

02. Renommer des fichiers par lots selon des conventions de nommage

• Scénario : Vous voulez uniformiser des noms incohérents comme IMG_0001.
• Méthode : « Renomme ces images par lots au format 'Date_Numéro de série'. »
• Effet : Même sans connaître les expressions régulières, vous pouvez nettoyer un grand nombre de fichiers en une seule fois.

03. Redimensionner et compresser des images par lots

• Scénario : Vous souhaitez alléger des images pour un blog.
• Méthode : « Redimensionne les images de ce dossier à 1200 px de large et convertis-les en WebP. »
• Effet : Pas besoin de chercher un outil de conversion, il suffit de demander le traitement par lots.

04. Trouver et organiser les fichiers en double

• Scénario : Des fichiers identiques sont éparpillés un peu partout, gaspillant de l'espace.
• Méthode : « Détecte les fichiers en double dans ce dossier et liste-les. »
• Effet : Vous voyez d'un coup d'œil lesquels sont supprimables sans risque.

05. Visualiser la structure des dossiers et suggérer des plans d'organisation

• Scénario : Vous ne savez pas comment organiser un dossier désordonné.
• Méthode : « Liste la structure de ce dossier et propose un plan d'organisation. »
• Effet : Vous obtenez une vue d'ensemble et des suggestions d'amélioration pour décider d'une politique de nettoyage.

2. Traitement et conversion de données

Vous pouvez confier les tâches de données fastidieuses impliquant des CSV, JSON, logs, etc.

06. Combiner et agréger plusieurs CSV

• Scénario : Les CSV mensuels sont séparés, vous voulez calculer les totaux.
• Méthode : « Combine ces 12 CSV et calcule le total des ventes par mois. »
• Effet : L'effort de copier-coller et d'agrégation dans Excel devient nul.

07. Nettoyer des données CSV/Excel désordonnées

• Scénario : Vous voulez corriger des données avec des en-têtes décalés ou trop de lignes vides.
• Méthode : « Supprime les lignes inutiles de ce CSV et formate-le en un tableau correct. »
• Effet : Il prend en charge tout le travail manuel de nettoyage des données.

08. Convertir des formats comme JSON ⇄ CSV

• Scénario : Vous voulez visualiser un JSON d'API dans un tableur.
• Méthode : « Convertis ce JSON en CSV. »
• Effet : Vous obtenez le format souhaité sur-le-champ, sans chercher d'outils de conversion.

09. Extraire les erreurs de gros fichiers journaux et créer un rapport

• Scénario : Vous ne savez pas où se trouve le problème dans un énorme fichier de log.
• Méthode : cat app.log | claude -p "Aggregate errors by type and create a report"
• Effet : Vous pouvez extraire les points clés de dizaines de milliers de lignes en quelques minutes.

10. Transcrire le texte d'une capture d'écran ou d'une image (OCR)

• Scénario : Vous ne voulez pas retaper un tableau ou du code à partir d'une image.
• Méthode : Collez la capture d'écran et dites : « Transcrit le texte dans cette image. »
• Effet : Le texte devient copiable sans saisie manuelle.

3. Écriture et correction de code

Bien sûr, il gère aussi le cœur du codage. Il est particulièrement efficace dans les situations où vous êtes bloqué.

11. Corriger des bugs en collant simplement les messages d'erreur

• Scénario : Vous ne comprenez pas le sens de l'erreur ni comment la corriger.
• Méthode : Collez l'erreur complète et dites : « Identifie la cause et corrige-la. »
• Effet : Avant même d'avoir cherché, la cause et une correction sont fournies en une fois.

12. Générer des tests automatisés avec « Write tests »

• Scénario : Vous avez peur de modifier du code car il n'y a pas de tests.
• Méthode : « Écris des tests pour cette fonction, en couvrant les cas principaux. »
• Effet : Déléguez la création fastidieuse des tests et refactorisez en toute sérénité.

13. Refactoriser des fonctions et des classes collectivement

• Scénario : Des fonctions longues sont difficiles à lire ou contiennent beaucoup de duplications.
• Méthode : « Divise cette fonction par responsabilité pour la rendre plus lisible. »
• Effet : La structure est nettoyée tout en conservant les fonctionnalités.

14. Lui faire créer des expressions régulières à partir de vos objectifs

• Scénario : Vous êtes mauvais en regex et bloquez à chaque fois.
• Méthode : « Crée une regex qui correspond aux numéros de téléphone. Inclus des exemples de test. »
• Effet : Vous obtenez une regex fonctionnelle immédiatement, sans tâtonnements.

15. Lui faire écrire du SQL à partir de besoins en français/anglais

• Scénario : Vous ne savez pas écrire des requêtes JOIN complexes ou des agrégations.
• Méthode : « Écris une requête SQL pour obtenir le top 10 des ventes par client du mois dernier. »
• Effet : Si vous fournissez la structure de la table, il sort une requête exécutable.

16. Ajouter des définitions/annotations de type au code existant

• Scénario : Vous voulez sécuriser du code non typé.
• Méthode : « Ajoute des annotations de type à ce fichier et corrige les erreurs de type. »
• Effet : Vous pouvez finir un typage en masse qui serait difficile à faire manuellement.

17. Traduire par lots les commentaires ou les messages de log

• Scénario : Vous voulez uniformiser des commentaires anglais en français (ou l'inverse).
• Méthode : « Traduis les commentaires de ce fichier en français. »
• Effet : Vous pouvez aligner les langues tout en préservant le sens.

18. Implémenter une ébauche de nouvelle fonctionnalité à partir de spécifications

• Scénario : C'est fastidieux de partir d'une page blanche.
• Méthode : « Crée une fonctionnalité qui fait X. Une ébauche fonctionnelle suffit pour l'instant. »
• Effet : Vous pouvez partir d'un prototype au lieu d'une page blanche.

4. Compréhension des bases de code

Vous pouvez également déléguer la tâche de « lire » du code hérité ou de nouveaux dépôts.

19. Lire l'intégralité du dépôt et expliquer la vue d'ensemble

• Scénario : Vous ne savez pas à quoi sert le code hérité.
• Méthode : claude → « Explique le tableau d'ensemble de ce que fait ce dépôt. »
• Effet : Vous pouvez saisir un nouveau projet en peu de temps.

20. Demander « Par où dois-je commencer à lire ? »

• Scénario : Vous ne connaissez pas le point d'entrée d'une énorme base de code.
• Méthode : « Quel fichier dois-je suivre pour retracer la fonctionnalité de connexion ? »
• Effet : Vous saurez l'ordre de lecture au lieu de chercher au hasard.

21. Expliquer des processus complexes avec des étapes ou des diagrammes

• Scénario : Une logique complexe ne tient pas dans votre tête.
• Méthode : « Explique le flux de ce processus étape par étape. »
• Effet : Le code se transforme en manuel en langage clair.

22. Générer automatiquement un README

• Scénario : Il n'y a pas de README, ou il est obsolète.
• Méthode : « Crée un README pour ce projet (Introduction, Utilisation, Structure). »
• Effet : Vous êtes libéré du travail lourd de documentation.

23. Créer des spécifications d'API à partir du contenu du code

• Scénario : Il est difficile d'écrire manuellement une liste d'endpoints.
• Méthode : « Crée une spécification pour cette API avec une description pour chaque endpoint. »
• Effet : Vous pouvez générer les spécifications les plus récentes directement à partir de l'implémentation.

5. Délégation de tâches Git / GitHub

Les tâches routinières comme les commits, les PR et la gestion de l'historique sont parfaites pour la délégation.

24. Diviser les modifications en unités pertinentes et commiter

• Scénario : Vous avez corrigé plusieurs choses et vous vous demandez comment diviser les commits.
• Méthode : « Divise les modifications en unités pertinentes et commite-les. »
• Effet : Vous obtenez un historique propre, et vous n'avez pas besoin d'écrire les messages vous-même.

25. Créer automatiquement une PR avec une description

• Scénario : Écrire des descriptions de PR est une corvée.
• Méthode : « Crée une PR pour les modifications en cours. Rédige la description en français. »
• Effet : Tout, du push à la description, est terminé automatiquement.

26. Générer un CHANGELOG à partir de l'historique des commits

• Scénario : Résumer manuellement les notes de version est fastidieux.
• Méthode : « Résume les modifications depuis le dernier tag dans un CHANGELOG. »
• Effet : Une liste des modifications est terminée sans avoir à relire l'historique.

27. Nettoyer les branches anciennes ou fusionnées

• Scénario : Les branches s'accumulent, ce qui rend la vue difficile.
• Méthode : « Liste les branches locales fusionnées. »
• Effet : Vous pouvez les vérifier en toute sécurité, puis les organiser en une seule fois.

28. Résoudre les conflits de fusion

• Scénario : Un conflit est apparu et a bloqué votre travail.
• Méthode : « Résous ce conflit en tenant compte des deux intentions. »
• Effet : Il prend en charge la tâche fastidieuse de faire correspondre les modifications.

29. Identifier « Quand ce bug a-t-il été introduit ? »

• Scénario : Vous ne savez pas quel commit a causé une panne.
• Méthode : « Identifie le commit qui a introduit ce bug à partir de l'historique git. »
• Effet : Vous pouvez cibler précisément les modifications suspectes.

6. Configuration de l'environnement, scripts et paramétrage

Faites-lui préparer des brouillons pour les tâches de configuration qui sont fastidieuses à rechercher et à écrire.

30. Créer des procédures ou des scripts d'installation

• Scénario : Les nouveaux membres bloquent lors de la configuration de l'environnement.
• Méthode : « Crée un script de configuration d'environnement pour ce projet. »
• Effet : Vous pouvez transformer des explications verbales en étapes exécutables.

31. Lui faire écrire des scripts shell pour les tâches courantes

• Scénario : Vous tapez manuellement les mêmes commandes à chaque fois.
• Méthode : « Crée un script qui sauvegarde le dossier spécifié et le compresse avec une date. »
• Effet : Vous pouvez transformer des répétitions fastidieuses en une seule commande.

32. Créer des brouillons pour Dockerfile / paramètres CI

• Scénario : Vous n'êtes pas familier avec Docker ou les paramètres GitHub Actions.
• Méthode : « Crée un Dockerfile et des paramètres CI pour cette application Node. »
• Effet : Vous obtenez un brouillon fonctionnel sans avoir à rechercher depuis zéro.

33. Générer des fichiers de configuration pour des besoins spécifiques

• Scénario : Vous ne voulez pas écrire .gitignore ou les paramètres de lint depuis zéro.
• Méthode : « Crée un .gitignore adapté à ce projet. »
• Effet : Des paramètres sans omissions sont prêts immédiatement.

34. Vérifier les vulnérabilités ou les dépendances obsolètes

• Scénario : Vous craignez de laisser des bibliothèques non maintenues.
• Méthode : « Vérifie les vulnérabilités dans les dépendances et vois lesquelles peuvent être mises à jour. »
• Effet : Les risques et les propositions de mise à jour sont listés, ce qui facilite les décisions.

7. Recherche et création de documents

Si vous fournissez les documents, il peut façonner informations et documents pour vous.

35. Rechercher sur le Web pour comparer et résumer

• Scénario : Vous voulez comparer des choix technologiques ou des informations récentes.
• Méthode : « Compare X et Y, et résume les critères de sélection. »
• Effet : Vous obtenez un résumé à partir de plusieurs sources.

36. Extraire les TODO de comptes rendus de réunion ou de notes

• Scénario : Vous voulez extraire les « choses à faire » de longues notes.
• Méthode : Collez les notes et dites : « Extrais les décisions et les TODO avec les responsables. »
• Effet : Les actions suivantes deviennent claires sans avoir à tout relire.

37. Résumer de longs textes ou documents

• Scénario : Vous n'avez pas le temps de lire un document.
• Méthode : « Résume ce fichier en une version de 3 lignes et une version détaillée. »
• Effet : Vous pouvez saisir l'ensemble rapidement avant de plonger dans les détails.

38. Créer des notes de conception ou des spécifications à partir du code

• Scénario : Il n'y a pas de spécifications, seule l'implémentation fait foi.
• Méthode : « Écris les spécifications de cette fonctionnalité en te basant sur le comportement réel. »
• Effet : Des spécifications qui n'existaient que dans la tête de quelqu'un deviennent un document.

39. Créer des diagrammes (Mermaid) à coller dans des documents

• Scénario : Dessiner des diagrammes d'architecture ou des organigrammes à la main est fastidieux.
• Méthode : « Transforme le flux de ce processus en un organigramme Mermaid. »
• Effet : Les diagrammes sont générés à partir du texte et peuvent être utilisés immédiatement dans des documents.

8. Optimisation de l'efficacité (Paramètres et automatisation)

Configurer ces éléments rend les tâches ci-dessus encore plus rapides et plus sûres.

40. Générer automatiquement des règles de projet avec /init

• Scénario : Vous voulez faciliter les paramètres initiaux.
• Méthode : /init
• Effet : Un fichier de règles (CLAUDE.md) qui analyse la structure est terminé en quelques secondes.

41. Lui faire mémoriser des règles à la volée avec #

• Scénario : Vous répétez « fais comme ça la prochaine fois » à chaque fois.
• Méthode : # Écris les messages de commit en français
• Effet : Une fois écrit, il suivra cette règle par la suite.

42. Transformer des instructions fréquemment utilisées en /commands

• Scénario : Vous tapez la même longue instruction plusieurs fois.
• Méthode : Enregistrez la procédure dans .claude/commands/ → Appelez-la avec /lint-fix
• Effet : Les tâches routinières peuvent être appelées en un seul mot.

43. Formater automatiquement à chaque sauvegarde (hooks)

• Scénario : Les commentaires de révision augmentent parce que vous oubliez de formater.
• Méthode : Définissez un hook (PostToolUse) pour exécuter le formateur après l'édition.
• Effet : Oublier de formater devient structurellement impossible.

44. Éviter les accidents avec « Planifier d'abord » pour les gros changements

• Scénario : L'impact est large, et exécuter immédiatement fait peur.
• Méthode : « Ne fais pas le travail encore. Donne-moi d'abord la procédure. »
• Effet : C'est la base de la prévention des accidents, stoppant les actions incontrôlées dès la première étape.

45. Déléguer la recherche à des sous-agents

• Scénario : Une longue investigation est nécessaire avant le sujet principal.
• Méthode : « Fais une recherche sur X avec un sous-agent et communique-moi uniquement les points clés. »
• Effet : La conversation n'est pas noyée dans les journaux de recherche, ce qui permet de se concentrer sur le sujet principal.

9. Intégrations, images et techniques de flux de travail

Intégration de services externes, entrée d'images et petites astuces pour stabiliser le travail quotidien.

46. Publier ou enregistrer en se connectant à Slack ou Drive (MCP)

• Scénario : Vous copiez et partagez manuellement les résultats à chaque fois.
• Méthode : Après la connexion MCP, « Publie les résultats sur Slack #développement. »
• Effet : Terminé jusqu'au partage avec une seule instruction, sans changer d'application.

47. Implémenter ou corriger une UI en collant des captures d'écran

• Scénario : Vous voulez construire un écran exactement comme une image de maquette.
• Méthode : Collez l'image et dites : « Corrige le CSS pour correspondre à ce design. »
• Effet : Vous pouvez transmettre des aspects visuels difficiles à expliquer avec des mots avec une seule image.

48. Identifier les causes en montrant des écrans d'erreur

• Scénario : Vous ne comprenez pas le sens d'un écran d'erreur de navigateur.
• Méthode : Collez la capture d'écran et dites : « Dis-moi la cause et la correction de cette erreur. »
• Effet : Vous pouvez consulter directement sans avoir à transcrire.

49. Reprendre un travail interrompu immédiatement avec claude -c

• Scénario : Vous voulez revenir à la suite d'un travail que vous avez fermé.
• Méthode : claude -c
• Effet : Reprenez tel quel, sans avoir à réexpliquer la situation.

50. Arrêter avec Esc, refaire avec /rewind

• Scénario : Cela progresse différemment, ou vous voulez annuler une modification.
• Méthode : Esc pour arrêter, /rewind pour revenir en arrière.
• Effet : Vous pouvez refaire en toute sécurité à tout moment, sans crainte d'échec.

Résumé

Claude Code est un outil pour écrire du code, mais c'est aussi un assistant polyvalent capable de gérer tout, de l'organisation de fichiers au traitement de données, en passant par la recherche et la création de documents. Je recommande de commencer par les « choses qui vous embêtent en ce moment », comme 01 (organisation des téléchargements), 09 (analyse de logs) ou 11 (correction de bugs). Une fois que vous vous y serez habitué, transformez-le en votre propre environnement de travail dédié grâce aux configurations 40–45.

Des fonctionnalités sont ajoutées ou modifiées dans différentes versions, alors vérifiez le comportement le plus récent avec /help et la documentation officielle (code.claude.com/docs).