Claude Craft partie 1 : 31 agents pour industrialiser Claude Code

Tu ouvres Claude Code sur ton projet Symfony. Tu tapes une demande de revue de PR. Claude te sort quelque chose de générique, sans aucune connaissance de ton architecture hexagonale, de tes conventions de nommage maison, de tes seuils de coverage ou de tes règles métier. Tu corriges à la main, tu réexpliques le contexte, tu recopies les mêmes consignes d'une session à l'autre. Ce n'est pas un problème de Claude — c'est un problème d'infrastructure. Et c'est exactement ce que Claude Craft résout, non pas en t'offrant un meilleur fichier de configuration, mais en changeant la nature même de ce que Claude Code peut être.

Pourquoi Claude Code seul atteint ses limites rapidement

Claude Code livré tel quel est générique par construction. Il ne connaît pas tes conventions PSR-12, ton architecture Doctrine, tes pipelines CI ou les contraintes de conformité de ton secteur. La réponse classique est de garnir le CLAUDE.md de règles en prose — et ça marche, jusqu'à un certain point. Le problème : ce fichier devient vite un fourre-tout illisible, mal versionné, non composable, et surtout non réutilisable d'un projet à l'autre. Chaque nouveau projet recommence de zéro. Chaque développeur qui rejoint l'équipe repart d'une page blanche. Chaque mise à jour de règles se fait à la main dans chaque dépôt. Ce n'est pas scalable. Claude Craft part d'un constat radicalement différent : les agents IA doivent être traités comme du code — versionnés, testés et déployés — pas comme des notes dans un fichier texte.

Ce que Claude Craft n'est pas (et ce qu'il est vraiment)

Claude Craft v8.18.1, documenté publiquement sur thebeardedbearsas.github.io/claude-craft, n'est pas un preset de prompts. Ce n'est pas un CLAUDE.md amélioré. Ce n'est pas une collection de snippets à copier-coller entre projets. C'est un framework open source qui structure Claude Code autour d'un principe fondateur : l'agent-as-code. Chaque agent est un artefact versionné — il a un nom, une version, un périmètre de responsabilité précis, des interfaces définies, et une capacité à être composé avec d'autres agents. Ces artefacts vivent dans ton dépôt git, ils passent en code review, ils sont taggés avec le reste du code, ils évoluent avec ton projet. La différence avec un CLAUDE.md enrichi est fondamentale : on passe d'une configuration déclarative en prose à une infrastructure d'agents reproductible, activable programmatiquement via Makefile, YAML ou script.

11 stacks, 31 agents, 126 commandes : l'architecture en chiffres

La v8.18.1 est construite autour de chiffres qui donnent l'échelle du projet comparé à un simple preset. Onze stacks technologiques couvrent l'ensemble du marché web et mobile moderne. Trente et un agents spécialisés peuvent être activés selon le contexte. Cent vingt-six slash commands automatisent les opérations récurrentes. Cinquante-cinq skills au format natif Claude Code étendent les capacités de l'outil. Vingt et un templates accélèrent la création d'artefacts. Dix checklists qualité structurent les processus de validation. L'ensemble est disponible en cinq langues nativement : anglais, français, espagnol, allemand et portugais. Le framework tourne sur Claude Code 2.1.168 en correspondance de version.

• Symfony — conventions PSR, architecture DDD/hexagonale, Doctrine, PHPUnit, API Platform
• Laravel — Eloquent ORM, Artisan, Blade, Livewire, patterns Laravel
• PHP — stack natif sans framework, règles bas niveau, compatibilité PHP 8.5+
• Python — FastAPI, typage strict Pydantic, async/await, mypy
• React — hooks, TypeScript strict, React Testing Library, Vite
• React Native — Expo, navigation, optimisation performances mobile
• Vue.js — Composition API, Pinia, Nuxt, TypeScript
• Angular — standalone components, signals, RxJS, architecture modulaire
• Flutter — Dart, state management, responsive UI cross-platform
• C#/.NET — ASP.NET Core, Entity Framework, Azure, architecture CQRS
• Infrastructure — Docker, Kubernetes, OpenTofu, Ansible, Hetzner Cloud, FrankenPHP, PgBouncer, Coolify

L'agent-as-code : quand les agents deviennent du code versionnable

C'est le concept le plus important du framework, et celui qui le distingue de toutes les approches précédentes. Avec Claude Craft, chaque agent est un fichier structuré dans ton dépôt. Tu actives tech-lead pour une session de revue d'architecture, api-designer pour la conception d'endpoints REST, accessibility-expert pour un audit WCAG, devops-engineer pour l'analyse de ta configuration Kubernetes — puis tu les combines dans un pipeline orchestré par bmad-master. Ce n'est plus du prompt one-shot : c'est une composition d'experts avec des responsabilités délimitées, des interfaces connues et des comportements reproductibles. Chaque agent peut être activé par trigger (création de PR, modification de Dockerfile, nouvel endpoint) ou invoqué directement via slash command. Et parce que ces définitions sont dans ton dépôt, elles évoluent avec ton projet, elles sont reviewées comme du code, elles peuvent être forkées, personnalisées, testées.

Voici un exemple de configuration YAML qui orchestre plusieurs agents sur un projet Symfony avec quality gates activées :

# .claude-craft.yml — projet Symfony API
version: "8"
tech: symfony
lang: fr

agents:
  - id: tech-lead
    scope: src/
    triggers:
      - on: pull_request
        action: architecture-review
  - id: api-designer
    scope: src/Controller/
    triggers:
      - on: new_endpoint
        action: openapi-spec
  - id: devops-engineer
    scope: docker/
    triggers:
      - on: dockerfile_change
        action: security-scan

quality_gates:
  enabled: true
  coverage_threshold: 80
  complexity_max: 10
  duplicates_max: 3

Installer Claude Craft sur un projet existant

L'installation est conçue pour ne pas casser l'existant. Trois méthodes sont disponibles selon le contexte : npx pour un projet unique (le plus rapide, zéro prérequis), Makefile pour une installation Symfony clé en main, script direct si tu veux un contrôle granulaire sur ce qui est installé. Voici les commandes pour les cas les plus fréquents :

# Installation rapide via npx — projet React, langue française
npx @the-bearded-bear/claude-craft install . --tech=react --lang=fr

# Installation Symfony via Makefile (cible un projet existant)
make install-symfony TARGET=~/mon-projet-symfony

# Installation pour un monorepo via config YAML
make config-install PROJECT=mono

# Installation manuelle avec contrôle granulaire
./scripts/install-rules.sh --tech=symfony --lang=fr \
  --agents=tech-lead,api-designer,devops-engineer

Pour un monorepo — cas typique d'un projet avec une API Symfony, un front React et un dossier infrastructure — le fichier .claude-craft.yml à la racine pilote l'installation différenciée par package. Chaque entrée reçoit son propre stack technologique et sa propre liste d'agents :

# .claude-craft.yml — monorepo multi-stack
version: "8"
lang: fr

packages:
  - path: apps/api
    tech: symfony
    agents: [tech-lead, api-designer, devops-engineer]

  - path: apps/frontend
    tech: react
    agents: [uiux-orchestrator, accessibility-expert, tech-lead]

  - path: infrastructure
    tech: infra
    agents: [devops-engineer, bmad-master]

quality_gates:
  enabled: true
  gates: 5

Ce que tu obtiens après l'installation

Après exécution, Claude Craft injecte dans ton projet un ensemble de fichiers structurés que Claude Code charge automatiquement au démarrage de chaque session. Tu n'as plus à réexpliquer ton stack, tes conventions ou tes standards à chaque nouvelle conversation. Les agents sont activables immédiatement via les 126 slash commands documentées. Le status line de ton terminal affiche la branche git courante et l'état des agents actifs en temps réel.

• CLAUDE.md enrichi et structuré avec les règles du stack sélectionné, les conventions et les standards qualité du projet
• Dossier .claude/agents/ contenant les définitions YAML des 31 agents activables
• Dossier .claude/commands/ avec les 126 slash commands prêtes à l'emploi
• Dossier .claude/skills/ avec les 55 skills au format natif Claude Code (code-review, security-review, simplify, deep-research…)
• Dossier .claude/templates/ avec 21 templates pour la génération d'artefacts (controller, service, test, migration, spec OpenAPI…)
• Dossier .claude/checklists/ avec 10 checklists qualité pour les processus de validation (PR review, deploy, security audit…)
• Status line terminal configuré avec suivi de branche git et monitoring des agents actifs

BMAD v6 et Ralph Wiggum : les deux orchestrateurs du système

Deux agents méritent une attention particulière parce qu'ils opèrent à un niveau méta — ils coordonnent les autres agents plutôt que d'exécuter des tâches techniques directement. bmad-master est l'orchestrateur principal, construit sur le framework BMAD v6. Il embarque 9 personas Agent-as-Code, 5 quality gates avec seuils configurables, un système de routing basé sur le statut des tâches et du batch processing pour les opérations lourdes. Concrètement, c'est lui qui coordonne un sprint complet — du grooming à la revue finale, en passant par la génération de specs, la délégation aux agents spécialisés et la validation qualité à chaque étape. ralph-conductor (Ralph Wiggum v2.0) joue un rôle différent et complémentaire : c'est un circuit breaker adaptatif avec monitoring de santé. Il surveille les agents en cours d'exécution, détecte les dérives de comportement, mesure la qualité des sorties et réoriente le workflow quand un agent sort de son périmètre ou produit des résultats dégradés. Ensemble, ils transforment une session Claude Code isolée en un pipeline d'agents coordonné, résilient et observable — ce qu'on attend d'un système en production.

Claude Craft v8.18.1 représente un changement de paradigme concret pour les équipes qui utilisent Claude Code au quotidien : les agents IA passent du statut de prompts jetables à celui d'artefacts versionnés, composables et activables programmatiquement. Pour un projet existant, l'installation prend moins de dix minutes. La suite de cette série explorera chaque stack en détail — Symfony en partie 2, Infrastructure en partie 3. Si tu veux structurer l'adoption de Claude Code dans ton équipe avec une architecture adaptée à ton contexte produit et tes standards qualité, le Workshop Claude Code ou un accompagnement CTO as a Service sont les deux formats qui permettent de passer de l'expérimentation à l'industrialisation en quelques semaines.