Ludovic Couveignes

IA : comment créer une usine agentic pour Claude Code

Ludovic couveignes devnet IA claude code

Le concept

Une « usine agentic » (agentic factory) est une chaîne d’agents Claude Code orchestrés qui transforment un besoin métier en code livré, testé et déployé — sans intervention humaine à chaque étape. L’objectif : passer du copilote ponctuel à un pipeline reproductible.

Architecture type:

Ticket/Spec → Agent Planner → Agent Coder → Agent Tester → Agent Reviewer → Agent Deployer

Chaque agent est une instance Claude Code avec :

  • un rôle restreint (un seul prompt système, une seule responsabilité)
  • un scope de fichiers limité (working directory dédié)
  • des outils explicites (bash, git, tests, lint — pas plus que nécessaire)
  • une sortie structurée consommée par l’agent suivant

Architecture type

Ticket/Spec → Agent Planner → Agent Coder → Agent Tester → Agent Reviewer → Agent Deployer

Les briques essentielles

1. Orchestration

Utilisez Claude Code en mode headless (claude -p "..." ou SDK) piloté par un script (Python/Node) ou un outil comme Claude Code Remote avec des triggers planifiés. Chaque étape du pipeline appelle Claude Code avec un prompt précis et un contexte minimal.

2. Isolation

Chaque agent tourne dans son propre worktree git ou conteneur. Cela évite les collisions de fichiers et permet le parallélisme (plusieurs features en cours simultanément).

3. Contrats inter-agents

Définissez un format de sortie strict (JSON ou markdown structuré) pour chaque agent : statut, fichiers modifiés, tests exécutés, erreurs. Sans contrat, l’agent suivant ne peut pas réagir intelligemment.

4. Boucles de vérification

  • Le Coder ne passe jamais directement en prod.
  • Le Tester relance la suite de tests et bloque si échec.
  • Le Reviewer applique des règles statiques (lint, sécurité, conventions) avant tout merge.

5. Garde-fous humains

Un point de validation humaine reste recommandé avant déploiement en prod, surtout sur les premières itérations. L’automatisation totale vient après confiance acquise.

Exemple de pipeline minimal

				
					# 1. Planification
claude -p "Analyse ce ticket et génère un plan d'implémentation : $TICKET" > plan.md

# 2. Implémentation
claude -p "Implémente ce plan dans le repo : $(cat plan.md)" --add-dir ./repo

# 3. Tests
claude -p "Exécute la suite de tests, corrige les échecs si besoin" --add-dir ./repo

# 4. Review
claude -p "Review ce diff selon nos conventions internes" --add-dir ./repo

# 5. PR
gh pr create --fill
				
			

Intégrer des Skills dans l’usine

Les Skills (dossiers SKILL.md + scripts/ressources) permettent de standardiser le savoir-faire métier que chaque agent doit appliquer, sans le réécrire dans chaque prompt. C’est l’équivalent de librairies partagées, mais pour le comportement des agents.

Structure d’un skill

				
					skills/
  pr-review/
    SKILL.md          # description, déclencheurs, checklist
    rules.md          # règles de code détaillées
  release-notes/
    SKILL.md
    template.md
  db-migration/
    SKILL.md
    scripts/check_migration.py
				
			

Le SKILL.md contient une description précise qui sert de déclencheur :

—
name: pr-review
description: Utiliser ce skill pour reviewer une PR avant merge. Vérifie les
conventions de nommage, la couverture de tests, les secrets exposés et la
cohérence avec l’architecture du repo.
—

## Checklist de review
1. Pas de secret/clé en dur (grep des patterns courants)
2. Tests ajoutés pour toute nouvelle fonction publique
3. Respect des conventions de nommage (voir rules.md)
4. Pas de TODO non justifié

Exemple : agent reviewer avec skill

				
					claude -p "Génère les release notes pour cette version à partir des commits" \
  --add-dir ./repo \
  --add-dir ./skills/release-notes
				
			

Le skill impose le template (catégories Breaking/Features/Fixes), garantissant une sortie homogène d’une release à l’autre, quel que soit l’agent qui l’exécute.

Exemple : agent Coder avec skill « db-migration »

				
					claude -p "Implémente la migration décrite dans le ticket" \
  --add-dir ./repo \
  --add-dir ./skills/db-migration
				
			

Le skill embarque un script de vérification (check_migration.py) que l’agent appelle automatiquement avant de considérer la tâche terminée — évitant les migrations non réversibles ou mal indexées.

Pourquoi c’est puissant dans une usine agentic

  • Cohérence : tous les agents Coder/Reviewer appliquent les mêmes règles, peu importe le prompt d’origine.
  • Maintenance centralisée : on corrige une règle dans un seul SKILL.md, tous les pipelines en bénéficient.
  • Découplage prompt/connaissance métier : le prompt reste court (« review ce diff »), le skill porte la complexité.
  • Versionnable : les skills vivent dans le repo (git), donc auditables et testables comme du code.

Bonnes pratiques

  • Petits agents > un agent généraliste : un prompt système court et ciblé donne de meilleurs résultats qu’un agent « fait tout ».
  • Logging systématique : chaque exécution doit être traçable (prompt, sortie, diff, durée).
  • Coût et latence : surveillez le nombre de tokens/appels par pipeline ; ajoutez des limites.
  • Rollback facile : chaque étape doit pouvoir être annulée (branches git dédiées).
  • Itérez sur les prompts comme du code : versionnez-les, testez-les avec des cas réels.

Pièges à éviter

  • Donner un accès trop large (tout le repo, tous les outils) à un agent qui n’en a pas besoin.
  • Enchaîner les agents sans validation intermédiaire automatisée.
  • Laisser un agent déployer en prod sans tests bloquants.
  • Sous-estimer le coût cumulé sur des pipelines à fort volume.

Conclusion

Une usine agentic n’est pas un seul gros agent magique, mais une chaîne d’agents spécialisés, isolés et vérifiés à chaque étape. C’est une discipline d’ingénierie logicielle classique (séparation des responsabilités, contrats clairs, tests) appliquée à des agents IA plutôt qu’à des microservices.

Partagez

Autres articles

ludovic couveignes devnet article microservice Développeur Microsoft

Architecture Microservice

Introduction L’architecture microservices est une méthode de développement logiciel qui divise une application en plusieurs services indépendants. Cette approche facilite la maintenance, la scalabilité et

Read More »