Skills d'agent dans Claude Code : étendez les capacités de Claude

Que sont les skills ?

Les skills sont des capacités réutilisables que Claude apprend et applique automatiquement. Quand Claude accomplit avec succès un pattern de tâche, il peut sauvegarder cette connaissance comme un skill pour un usage futur.

Exemple : avant les skills

À chaque fois que vous demandez à Claude de déployer :

> Déploie en staging

Quel est votre processus de déploiement ? Utilisez-vous Docker, 
Kubernetes, ou une plateforme comme Vercel ? Quelles 
variables d'environnement sont nécessaires ?

Claude pose les mêmes questions à chaque session.

Exemple : avec les skills

Claude se souvient de votre pattern de déploiement :

> Déploie en staging

Utilisation du skill appris : "Déploiement Staging"
1. Exécution des tests...
2. Construction de l'image Docker...
3. Push vers le registre...
4. Mise à jour du déploiement Kubernetes...
5. Vérification des health checks...

✓ Déployé en staging avec succès

Claude applique ce qu'il a appris précédemment.

Comment fonctionnent les skills

Le cycle de vie des skills suit trois étapes :

1. Découvrir → Claude trouve des patterns dans votre workflow

2. Utiliser → Claude applique automatiquement les skills appris

3. Affiner → Claude améliore les skills en fonction des retours

Ce cycle se répète continuellement au fil de votre travail avec Claude Code.

Découverte des skills

Claude identifie des patterns à partir de :

1. →Fichiers CLAUDE.md : Conventions documentées
2. →Analyse du code : Patterns existants dans le code
3. →Historique de session : Tâches accomplies avec succès
4. →Enseignement explicite : Quand vous expliquez à Claude comment faire quelque chose

Stockage des skills

Les skills sont stockés dans :

• →~/.claude/skills/ — Skills au niveau utilisateur
• →.claude/skills/ — Skills au niveau projet
• →Contexte mémoire — Capacités dérivées de la session

Application des skills

Quand vous faites une demande, Claude :

1. →Vérifie les skills pertinents
2. →Applique les patterns correspondants
3. →S'adapte au contexte actuel
4. →Exécute avec les connaissances apprises

Skills intégrés

Claude Code est livré avec des skills fondamentaux :

Ceux-ci sont enrichis par l'apprentissage spécifique au projet.

Fichiers de skills

Anatomie d'un fichier de skill

# .claude/skills/deploy-staging.yaml
name: deploy-staging
description: Déployer l'application en environnement staging
version: "1.0"

triggers:
  - "deploy to staging"
  - "staging deployment"
  - "update staging"

prerequisites:
  - All tests passing
  - On main or develop branch
  - Docker daemon running

steps:
  - Run test suite: npm test
  - Build Docker image: docker build -t app:staging .
  - Push to registry: docker push registry/app:staging
  - Update Kubernetes: kubectl rollout restart deployment/app -n staging
  - Verify health: curl -f https://staging.example.com/health

tools_used:
  - Bash(npm:test)
  - Bash(docker:*)
  - Bash(kubectl:*)

notes: |
  - Staging uses the staging-config configmap
  - Health check may take 30-60 seconds
  - Notify #deployments on Slack after completion

Propriétés des skills

Créer des skills

À partir d'une conversation

Demandez à Claude de sauvegarder un pattern :

> Ce processus de déploiement a très bien fonctionné. Sauvegarde-le comme skill.

Skill sauvegardé : "Déploiement Staging"

Déclencheurs :
- deploy to staging
- staging deployment
- update staging

Étapes capturées :
1. npm test
2. docker build -t app:staging .
3. docker push registry/app:staging
4. kubectl rollout restart...
5. Vérification du health check

Skill sauvegardé dans : .claude/skills/deploy-staging.yaml

Création manuelle

Créez directement des fichiers de skills :

# .claude/skills/code-review.yaml
name: code-review
description: Revue de code exhaustive selon les standards de l'équipe

triggers:
  - "review this code"
  - "code review"
  - "/review"

steps:
  - Check for ESLint errors: npm run lint
  - Verify TypeScript types: npm run typecheck
  - Review changes: git diff HEAD~1
  - Analyze for security issues
  - Check test coverage for changed files
  - Summarize findings with severity ratings

context:
  style_guide: docs/STYLE_GUIDE.md
  security_rules: docs/SECURITY.md

À partir de CLAUDE.md

Les skills peuvent référencer les conventions de CLAUDE.md :

# .claude/skills/create-component.yaml
name: create-component
description: Créer un composant React selon les conventions du projet

triggers:
  - "create component"
  - "new component"
  - "generate component"

context_from_claude_md:
  - Component structure conventions
  - Styling approach (CSS modules)
  - Testing requirements

steps:
  - Create component file in src/components/
  - Add TypeScript types
  - Create CSS module
  - Generate unit tests
  - Add Storybook story if UI component

Catégories de skills

Skills de développement

# Créer un endpoint API
name: create-api-endpoint
triggers: ["create endpoint", "new api route", "add endpoint"]
steps:
  - Create route handler
  - Add request validation
  - Implement service logic
  - Add error handling
  - Generate tests
  - Update API documentation

Skills de test

# Générer des tests exhaustifs
name: test-generation
triggers: ["generate tests", "create tests", "add tests for"]
steps:
  - Analyze target code structure
  - Identify test scenarios
  - Create unit tests for functions
  - Create integration tests for modules
  - Add edge case coverage
  - Verify tests pass

Skills de refactoring

# Extraire et refactoriser
name: extract-component
triggers: ["extract component", "refactor into component"]
steps:
  - Identify extractable code
  - Create new component file
  - Move code with proper imports
  - Update original file
  - Add TypeScript types
  - Verify functionality preserved
  - Run affected tests

Skills DevOps

# Migration de base de données
name: create-migration
triggers: ["create migration", "add migration", "database change"]
steps:
  - Generate migration file
  - Add up/down operations
  - Update schema types
  - Run migration locally
  - Verify data integrity
  - Create rollback test

Héritage des skills

De l'utilisateur au projet

Les skills utilisateur fournissent les valeurs par défaut, les skills projet les surchargent :

Skills utilisateur (~/.claude/skills/) :

• →deploy.yaml - Déploiement générique
• →test.yaml - Tests génériques
• →review.yaml - Revue générique

Skills projet (project/.claude/skills/) :

• →deploy.yaml - Spécifique au projet (surcharge l'utilisateur)
• →ci-check.yaml - Ajout spécifique au projet

Composition de skills

Les skills peuvent s'appuyer sur d'autres skills :

# .claude/skills/release.yaml
name: release
description: Processus de release complet

triggers:
  - "release"
  - "create release"
  - "new version"

composed_of:
  - code-review      # Lancer la revue de code d'abord
  - test-generation  # Assurer la couverture de tests
  - deploy-staging   # Déployer en staging
  - verify-staging   # Vérifier le staging

additional_steps:
  - Update version in package.json
  - Generate changelog
  - Create git tag
  - Deploy to production
  - Create GitHub release

Contexte des skills

Fournir du contexte aux skills

Les skills peuvent référencer du contexte externe :

# .claude/skills/api-design.yaml
name: api-design
description: Concevoir une API selon les standards de l'entreprise

context_files:
  - docs/API_STANDARDS.md
  - docs/ERROR_CODES.md
  - src/types/api.ts

context_patterns:
  - Existing API routes in src/api/
  - Current error handling patterns
  - Response format standards

Contexte dynamique

Les skills s'adaptent à l'état actuel :

# .claude/skills/debug.yaml
name: debug
description: Déboguer le problème actuel

dynamic_context:
  - Current error messages
  - Recent code changes (git diff)
  - Relevant test failures
  - Related stack traces

steps:
  - Gather error context
  - Identify potential causes
  - Check recent changes
  - Propose fixes
  - Test fix locally

Gérer les skills

Lister les skills

> Quels skills as-tu pour ce projet ?

Skills disponibles :

Skills projet :
- deploy-staging : Déployer en environnement staging
- code-review : Revue de code selon les standards de l'équipe
- create-component : Créer un composant React
- create-endpoint : Créer un endpoint API

Skills utilisateur :
- git-workflow : Workflow standard de commit git
- documentation : Générer de la documentation

Skills intégrés :
- refactoring : Patterns de refactoring de code
- testing : Génération de tests
- debugging : Recherche et correction de bugs

Voir les détails d'un skill

> Montre-moi le skill deploy-staging

Skill : deploy-staging
Version : 1.2
Dernière utilisation : il y a 2 heures
Taux de succès : 95 %

Déclencheurs :
- deploy to staging
- staging deployment
- update staging

Prérequis :
- Tests passants
- Sur la branche main/develop
- Docker en cours d'exécution

Étapes :
1. npm test
2. docker build -t app:staging .
3. docker push registry/app:staging
4. kubectl rollout restart...
5. curl -f staging/health

Notes :
- Utilise le configmap staging-config
- Le health check prend 30-60s

Mettre à jour les skills

> Mets à jour le skill deploy pour aussi lancer le linting

Skill mis à jour : deploy-staging

Étape ajoutée avant les tests :
- npm run lint

Version mise à jour : 1.2 → 1.3

Supprimer des skills

> Supprime le skill old-deploy

Skill supprimé : old-deploy
Fichier précédent archivé dans : .claude/skills/.archive/old-deploy.yaml

Optimisation des skills

Apprendre des échecs

Quand les skills échouent, Claude apprend :

> Déploie en staging

Utilisation du skill : deploy-staging

Étape 3 échouée : docker push registry/app:staging
Erreur : Authentification requise

Voulez-vous que je :
1. Ajoute une étape d'authentification au skill
2. Passe et continue manuellement
3. Mette à jour le skill avec le nouveau registre

> 1

Skill mis à jour avec :
- Pré-étape : docker login registry (avec identifiants env)
- Sauvegardé dans deploy-staging v1.4

Statistiques des skills

Suivez les performances des skills :

> Montre les statistiques des skills

Utilisation des skills (30 derniers jours) :

| Skill           | Utilisations | Succès | Temps moy. |
|-----------------|--------------|--------|------------|
| deploy-staging  | 23           | 96 %   | 4,2 min    |
| code-review     | 45           | 100 %  | 2,1 min    |
| create-component| 12           | 100 %  | 1,5 min    |
| debug           | 31           | 84 %   | 6,8 min    |

Recommandations :
- Le skill debug a un taux de succès plus faible ; examiner les patterns d'échec
- deploy-staging pourrait bénéficier d'étapes parallèles

Les skills en pratique

Workflow : onboarding d'un nouveau développeur

> Configure un environnement de nouveau développeur

Utilisation des skills :
- environment-setup (skill système)
- project-setup (skill projet)

Étapes :
1. Vérification des prérequis système...
   ✓ Node 18+, Docker, Git installés

2. Installation des dépendances...
   ✓ npm install terminé

3. Configuration de l'environnement...
   ✓ .env.local créé à partir du modèle

4. Initialisation de la base de données...
   ✓ Conteneurs Docker démarrés
   ✓ Migrations appliquées

5. Vérification de la configuration...
   ✓ npm test : tous les tests passent
   ✓ npm run dev : serveur démarré

Environnement prêt ! Voir docs/DEVELOPMENT.md pour la suite.

Workflow : développement de fonctionnalité

> Crée une fonctionnalité de profil utilisateur

Utilisation des skills :
- create-component
- create-endpoint  
- test-generation

Création de la fonctionnalité profil utilisateur...

Composants :
✓ src/components/UserProfile.tsx
✓ src/components/UserAvatar.tsx
✓ src/components/UserSettings.tsx

API :
✓ src/api/profile/route.ts
✓ src/services/ProfileService.ts
✓ src/types/profile.ts

Tests :
✓ __tests__/components/UserProfile.test.tsx
✓ __tests__/api/profile.test.ts
✓ __tests__/services/ProfileService.test.ts

Documentation :
✓ Mise à jour de docs/API.md avec les endpoints de profil

Workflow : investigation de bug

> Il y a un bug où les utilisateurs ne peuvent pas mettre à jour leur email

Utilisation du skill : debug

Investigation :
1. Recherche du code de mise à jour d'email...
   Trouvé : src/api/users/update.ts

2. Vérification des changements récents...
   Dernière modification : il y a 3 jours (commit abc123)

3. Analyse du changement...
   Problème trouvé : Validation manquante pour les mises à jour avec le même email

4. Correction proposée :
   Ajouter la vérification : if (newEmail === currentEmail) return success;

5. Cas de test créé pour ce scénario

Appliquer la correction ? [o/n]

Intégration avec d'autres fonctionnalités

Skills + Commandes personnalisées

Les commandes peuvent invoquer des skills :

<!-- .claude/commands/feature.md -->
Créer une nouvelle fonctionnalité en utilisant nos skills standards :

1. Utiliser le skill create-component pour l'interface
2. Utiliser le skill create-endpoint pour l'API
3. Utiliser le skill test-generation pour la couverture
4. Utiliser le skill documentation pour la doc

Voir Commandes slash personnalisées dans Claude Code : créez les vôtres.

Skills + sous-agents

Les sous-agents héritent des skills :

> Utilise des sous-agents pour créer des tests pour tous les services

[Lancement des agents de test-generation...]
Chaque agent utilise : skill test-generation

Agent 1 : UserService → 12 tests
Agent 2 : OrderService → 18 tests
Agent 3 : PaymentService → 15 tests

Voir Sous-agents Claude Code : orchestrer des tâches complexes.

Skills + Hooks

Validez l'exécution des skills avec des hooks :

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "*",
      "command": "python .claude/hooks/skill-validation.py"
    }]
  }
}

Voir Hooks Claude Code : automatisez votre workflow de développement.

Skills + MCP

Les skills peuvent utiliser les outils MCP :

name: sync-issues
description: Synchroniser les issues GitHub avec le suivi local

tools_required:
  - mcp__github__list_issues
  - mcp__github__get_issue
  - Write(docs/TODO.md)

Voir Model Context Protocol (MCP) pour Claude Code : guide complet.

Bonnes pratiques

1. Commencer par la documentation

Documentez d'abord les patterns dans CLAUDE.md :

## Processus de déploiement

1. Lancer tous les tests
2. Construire l'image Docker
3. Pousser vers le registre
4. Mettre à jour Kubernetes
5. Vérifier le health check

Claude apprend de la documentation.

2. Laisser les skills évoluer

Ne sur-ingénieriez pas les skills initiaux :

# Commencer simple
name: deploy
steps:
  - npm test
  - npm run build
  - npm run deploy

# Évoluer selon les besoins
# v2 : Ajouter Docker
# v3 : Ajouter K8s
# v4 : Ajouter les health checks

3. Versionner vos skills

Suivez les changements dans le temps :

name: deploy
version: "2.1"
changelog:
  - "2.1": Added parallel test execution
  - "2.0": Migrated to Kubernetes
  - "1.0": Initial Docker-based deployment

4. Partager les skills en équipe

Committez les skills dans le contrôle de version :

• →.claude/skills/README.md - Documentation des skills
• →.claude/skills/deploy.yaml
• →.claude/skills/review.yaml
• →.claude/skills/testing.yaml
• →.claude/CLAUDE.md

5. Tester régulièrement les skills

Vérifiez que les skills fonctionnent toujours :

> Teste tous les skills du projet

Test des skills...

✓ deploy-staging : Succès (dry run)
✓ code-review : Succès
✗ create-migration : Échec (nouvelle syntaxe Prisma)
✓ test-generation : Succès

1 skill nécessite une mise à jour : create-migration

Points clés à retenir

1. →

   Les skills sont des comportements appris : Claude mémorise les patterns réussis.

2. →

   Sauvegardez les workflows précieux : Quand quelque chose fonctionne, sauvegardez-le comme skill.

3. →

   Les skills se composent : Construisez des skills complexes à partir de skills plus simples.

4. →

   Spécifiques au projet : Les skills s'adaptent à votre base de code et vos conventions.

5. →

   Amélioration continue : Les skills évoluent en fonction des retours et des échecs.

Maîtriser les capacités des agents

Les skills sont les briques de base d'agents IA performants. Apprenez à concevoir des agents qui exploitent efficacement les skills.

Dans notre Module 6 — Agents autonomes, vous apprendrez :

• →La conception des capacités d'agents
• →Les patterns d'orchestration de skills
• →La construction d'agents adaptatifs
• →La mesure de l'efficacité des agents

→ Découvrir le Module 6 : Agents autonomes