Aller au contenu
Data — Agent IA — claude code — skills — IA

Skills vs Agents : comprendre le modèle d’exécution de Claude Code

Skills, Agents, Workflows : Bien les comprendre permet de créer des workflows IA plus interactifs, spécialisés, parallélisables et évolutifs, sans perdre l’expérience conversationnelle.

Connaissez-vous la différence entre Skills et Agents ?

Lorsqu’on découvre Claude Code, l’un des concepts les plus déroutants est la distinction entre les Skills, les Agents et les Workflows.
À première vue, ils semblent résoudre le même problème : automatiser des tâches. En réalité, ils interviennent à des niveaux d’abstraction complètement différents.
Une fois cette séparation comprise, il devient beaucoup plus facile de concevoir des workflows de développement assisté par l’IA qui soient évolutifs.

Les trois couches

Une façon utile de penser à Claude Code est de le considérer comme trois couches complémentaires :

Vous
 │
 ▼
Skill
 │
 ├──► Agent
 │
 └──► Workflow
          │
          ├──► Agent
          ├──► Agent
          └──► Agent

Chaque couche a une responsabilité différente :

  • Les Skills orchestrent le travail interactif.
  • Les Agents exécutent des tâches isolées.
  • Les Workflows orchestrent plusieurs agents.

Comprendre la place de chacune est essentiel pour construire une automatisation maintenable.

Skills

Un Skill est simplement un ensemble d’instructions chargé dans la session Claude actuelle.
Ce n’est pas une instance d’IA distincte. Ce n’est pas une autre conversation. Il s’agit essentiellement d’un prompt supplémentaire qui guide Claude dans l’exécution d’une tâche spécifique.
Par exemple :

"Write a dataform model"
↓
Claude charge :
skills/write-dataform/SKILL.md
↓
Claude suit ces instructions
dans la conversation actuelle.↓

Comme le Skill s’exécute dans la conversation existante, il a accès à tout ce que Claude sait déjà :

  • les messages précédents
  • les fichiers déjà examinés
  • les réponses que vous avez fournies
  • le contexte en cours

Il peut également interrompre son exécution pour poser des questions supplémentaires.

Agents

Un Agent est fondamentalement différent.
Au lieu d’étendre la conversation actuelle, Claude lance une toute nouvelle session d’IA dédiée à une seule tâche.
On peut le voir comme le lancement d’un collaborateur temporaire.

Conversation actuelle
        │
        ▼
    Lancer un Agent
        │
        ▼
Nouvelle session Claude isolée
        │
        ▼
   Exécute la tâche
        │
        ▼
   Retourne le résultat
        │
        ▼
   La session disparaît

L’agent :

  • démarre sans historique de conversation
  • reçoit uniquement le prompt que vous lui fournissez
  • effectue sa tâche
  • retourne un résultat
  • se termine

Cela rend les agents sans état et prévisibles.

Le meilleur modèle mental

Une analogie étonnamment juste consiste à comparer les Skills et les Agents à l’exécution logicielle.

Ou, plus simplement encore :

Skill = appel de fonction
Agent = fonction serverless

Un Skill s’exécute au sein du même « processus ».

Un Agent s’exécute ailleurs et renvoie simplement son résultat.

Skills vs Agents

La distinction la plus importante concerne le contexte. Un Skill étend votre conversation actuelle. Un Agent en démarre une nouvelle.

Quand utiliser un Skill ?

Les Skills sont particulièrement adaptés lorsque la tâche dépend d’une conversation en cours.

Par exemple :

  • générer du code après avoir discuté des exigences
  • recueillir des informations auprès de l’utilisateur
  • planification interactive
  • workflows guidés en plusieurs étapes
  • tâches pour lesquelles les messages précédents sont importants

Caractéristiques typiques :

  • nécessite l’historique de la conversation
  • nécessite des questions de clarification
  • interactif
  • séquentiel

Quand utiliser un Agent ?

Les Agents excellent dans les tâches isolées.

Les exemples typiques incluent :

  • revue de code
  • analyse de sécurité
  • exécution de tests
  • génération de documentation
  • analyse statique

Ces tâches n’ont pas besoin de savoir ce dont vous discutiez vingt messages plus tôt.

Elles ont seulement besoin du dépôt et d’un prompt.

Caractéristiques typiques :

  • autonome
  • reproductible
  • sans état
  • parallélisable

Une règle simple

Posez-vous une seule question :

Cette tâche nécessite-t-elle tout ce dont nous avons déjà discuté ?

Si la réponse est oui : utilisez un Skill.

Si la réponse est non : utilisez un Agent.

Autre règle pratique :

Si vous deviez expliquer la conversation précédente à quelqu’un avant qu’il puisse effectuer la tâche, utilisez un Skill.

Sinon, un Agent est probablement le meilleur choix.

Workflows : orchestrer plusieurs agents

Dès que vous introduisez plusieurs agents, vous avez besoin de coordination.

C’est le rôle des Workflows. Au lieu d’exécuter une seule tâche, un workflow en coordonne plusieurs.

Par exemple :

Démarrer le Workflow
        │
        ├──────────────┐
        │              │
        ▼              ▼
Revue de code    Revue de sécurité
        │              │
        └──────┬───────┘
               ▼
        Exécuteur de tests
               ▼
      Synthétiser les résultats
               ▼
        Retourner le rapport

Contrairement aux Skills, les workflows peuvent répartir le travail en parallèle.

Les primitives typiques d’un workflow incluent :

  • agent() — exécute un agent
  • parallel() — exécute plusieurs agents simultanément
  • pipeline() — fait progresser le travail à travers plusieurs étapes
  • phase() — regroupe l’exécution en étapes logiques

Cela rend les workflows particulièrement adaptés aux pipelines d’automatisation.

Combiner Skills et Workflows

L’architecture la plus puissante ne consiste pas à choisir l’un plutôt que l’autre.

Il s’agit de les combiner.

Une exécution typique peut ressembler à ceci :

Utilisateur
 │
 ▼
Skill
 │
 ├── recueille les exigences
 ├── pose des questions de clarification
 ├── génère du code
 │
 └────────► Lance le Workflow
                 │
                 ├── Réviseur de code
                 ├── Réviseur de sécurité
                 ├── Exécuteur de tests
                 │
                 ▼
           Rapport consolidé
                 │
                 ▼
           Le Skill reprend

Le Skill gère la partie interactive. Le Workflow gère l’automatisation.

L’utilisateur bénéficie d’une interaction continue tandis que le travail lourd est effectué par des agents isolés et parallèles.

Appeler des Agents depuis des Skills

Comme les Skills sont simplement des instructions exécutées par Claude, ils peuvent naturellement demander le lancement d’un Agent à n’importe quel moment.

Par exemple, après avoir généré un nouveau fichier source, le Skill peut demander à Claude de :

  1. lancer un agent de revue de code,
  2. attendre le résultat,
  3. corriger les problèmes critiques identifiés,
  4. poursuivre le workflow.

Le Skill reste interactif tout en déléguant le travail spécialisé à des agents isolés.

Appeler des Workflows depuis des Skills

Le même principe s’applique aux workflows. Un Skill peut générer du code puis lancer un workflow chargé de :

  • revue de code
  • revue de sécurité
  • tests automatisés

Comme les workflows peuvent exécuter plusieurs agents simultanément, la validation devient nettement plus rapide tout en conservant une expérience de création interactive inchangée.

Construire un Skill orchestrateur

À mesure que les systèmes grandissent, les utilisateurs souhaitent souvent disposer d’un point d’entrée unique.

Plutôt que de mémoriser des dizaines de workflows, un seul Skill peut jouer le rôle de routeur.

L’idée est simple :

Demande de l’utilisateur
       │
       ▼
Skill orchestrateur
       │
       ▼
Lit router.json
       │
       ▼
Identifie l’intention correspondante
       │
       ▼
Lance le Workflow
       │
       ▼
Retourne les résultats

Un fichier de routage pourrait associer les intentions de l’utilisateur à des workflows :

Intention de l’utilisateur    Workflow
Réviser mon code              review-all
Écrire un modèle Dataform     write-and-validate
Livrer une fonctionnalité     full-development-pipeline

La responsabilité de l’orchestrateur est minimale :

  1. interpréter la demande de l’utilisateur,
  2. sélectionner le workflow approprié,
  3. le lancer,
  4. retourner le résultat.

Ajouter une nouvelle capacité revient alors à ajouter une route supplémentaire plutôt qu’à modifier la logique d’orchestration.

Skills seules vs Skills + Agents

Le choix entre ces deux architectures dépend de la complexité de votre automatisation.
Pour les petites équipes et le développement interactif, les Skills seuls sont souvent suffisants.
À mesure que l’automatisation se développe, l’introduction d’Agents permet d’isoler, de paralléliser et de spécialiser le travail sans sacrifier l’expérience conversationnelle.

Journalisation et traçage de l’exécution

Les Workflows permettent également de construire des traces d’exécution robustes.
Une approche courante consiste à maintenir un objet de trace en mémoire pendant l’exécution du workflow :

Workflow
   │
   ├── Enregistrer l’étape
   ├── Enregistrer la réussite
   ├── Enregistrer l’échec
   ├── Enregistrer la sortie synthétisée
   │
   ▼
Exporter la trace JSON

Une trace peut contenir des informations telles que :

  • l’état du workflow
  • les étapes terminées
  • les étapes échouées
  • les résultats d’exécution
  • les messages d’erreur

Exporter la trace au format JSON permet d’examiner les échecs après l’exécution, de créer des tableaux de bord ou d’intégrer les exécutions de workflows dans des systèmes CI/CD.

Conclusion

La distinction entre Skills, Agents et Workflows devient simple dès lors qu’on les considère comme différents modèles d’exécution plutôt que comme des fonctionnalités concurrentes.

  • Les Skills sont des orchestrateurs interactifs et conscients du contexte qui s’exécutent dans votre conversation actuelle.
  • Les Agents sont des travailleurs isolés et sans état, conçus pour effectuer des tâches autonomes.
  • Les Workflows coordonnent plusieurs agents, permettant l’exécution en parallèle, l’isolation des erreurs et l’automatisation à grande échelle.

Plutôt que de se remplacer, ces trois couches se complètent.
L’architecture la plus efficace est généralement la suivante :

  • Utilisez les Skills pour les tâches interactives et riches en contexte.
  • Utilisez les Agents pour les unités de travail isolées.
  • Utilisez les Workflows pour orchestrer des groupes d’agents en parallèle.

Cette approche en couches combine la flexibilité du développement piloté par la conversation avec l’évolutivité et la fiabilité de l’exécution distribuée des tâches.

Dernier