Intégration dans les workflows

Ce tutoriel explique comment assembler vos skills, personas, agents et profiles dans un workflow cohérent.

Le principe

Un workflow orchestre des composants indépendants dans un pipeline :

Profile  →  charge le contexte technique
Skill    →  orchestre les étapes
Persona  →  exécute chaque étape
Agent    →  tâches autonomes déléguées
Workflow →  documente le flux global

Cas concret : workflow "API Feature"

Vous voulez créer un workflow complet pour ajouter des features API dans votre projet FastAPI.

1. Composants nécessaires

Composant	Type	Rôle
python-fastapi	Profile	Conventions FastAPI
analyst	Persona	Clarifier le besoin
dba	Persona (custom)	Designer le schéma
developer	Persona	Implémenter
migration-checker	Agent	Vérifier les migrations
code-reviewer	Agent	Review automatique
/api-feature	Skill	Orchestrer le tout

2. Créer le skill orchestrateur

---
name: api-feature
description: |
  Pipeline complet pour ajouter une feature API :
  specs → schéma DB → implémentation → migrations → review.
allowed-tools: Read, Write, Edit, Bash, Glob, Grep
---

# /api-feature

## Pipeline

### Step 01 — Spécifications

<persona>analyst</persona>

1. Clarifier le besoin avec l'utilisateur
2. Écrire les user stories avec critères d'acceptation
3. Identifier les entités de données

<gate>Specs validées → type `next`</gate>

### Step 02 — Design schéma DB

<persona>dba</persona>

1. Concevoir le schéma basé sur les entités du step 01
2. Définir les index et contraintes
3. Planifier la migration (zero downtime)

<gate>Schéma approuvé → type `next`</gate>

### Step 03 — Implémentation

<persona>developer</persona>

1. Créer la migration Alembic selon le plan du DBA
2. Créer le model SQLAlchemy
3. Créer les schemas Pydantic
4. Créer le service
5. Créer le router
6. Écrire les tests

<gate>Tests passent → type `next`</gate>

### Step 04 — Validation automatique

Lancer en parallèle :
- Agent `migration-checker` sur `alembic/versions/`
- Agent `code-reviewer` sur les fichiers modifiés

Si findings 🔴 → retour step 03.
Si tout ✅ → step 05.

### Step 05 — Commit

Commit conventionnel :
\`\`\`
feat(api): add {feature} endpoints
\`\`\`

3. Documenter le workflow

Créez framework/workflows/api-feature-pipeline.md :

# API Feature Pipeline

## Flux

\`\`\`
Analyst → DBA → Developer → [Agents] → Commit
 specs    schema   code     check
\`\`\`

## Gates

| Transition | Condition |
|-----------|-----------|
| Analyst → DBA | Specs validées, entités identifiées |
| DBA → Developer | Schéma approuvé, migration planifiée |
| Developer → Agents | Code compile, tests passent |
| Agents → Commit | Pas de finding 🔴 |

## Adaptation

| Complexité | Pipeline |
|------------|----------|
| Simple (1 table) | Step 03 → 05 |
| Moyenne (2-3 tables) | Step 02 → 03 → 04 → 05 |
| Complexe (relations) | Step 01 → 02 → 03 → 04 → 05 |

4. Activer le profil

Dans CLAUDE.md :

profile: python-fastapi

5. Utiliser

/api-feature add product catalog with categories and tags

Le skill orchestre automatiquement : analyst → dba → developer → agents → commit.

---

Comment les profils interagissent avec les personas

Sans profil :
  Architect pense "générique" → propose des patterns vagues

Avec profil python-fastapi :
  Architect pense "FastAPI" → propose Depends(), APIRouter, Pydantic v2

Avec profil rust + tauri :
  Architect pense "Tauri" → propose #[tauri::command], Managed State

Le profil ne change pas qui est le persona. Il change ce qu'il sait.

Comment les agents interagissent avec les skills

Un skill peut lancer des agents à n'importe quel step :

### Step 04 — Validation

Lancer l'agent `code-reviewer` sur les fichiers modifiés.

Si le rapport contient des findings 🔴 Critical :
  → Retourner au step 03 avec la liste des findings
Si tout est ✅ :
  → Passer au step 05

Les agents sont des checkpoints automatiques dans le pipeline.

Créer un workflow complet from scratch

Checklist

• [ ] Identifier les étapes du processus
• [ ] Pour chaque étape, choisir un persona (ou en créer un)
• [ ] Identifier les agents de validation nécessaires
• [ ] Définir les gates entre chaque étape
• [ ] Créer le skill orchestrateur
• [ ] Documenter le workflow (diagramme de flux)
• [ ] Créer/configurer le profil technologique
• [ ] Référencer le skill dans CLAUDE.md
• [ ] Tester sur 2-3 cas réels

Pattern de composition

Profils (contexte)
    ↓
Skill (orchestration)
├── Step 01: Persona A
│   └── Gate
├── Step 02: Persona B
│   └── Gate
├── Step 03: Persona C
│   └── Agent X (validation)
│   └── Agent Y (validation)
│   └── Gate (agents ✅?)
└── Step 04: Commit
    ↑
Workflow (documentation)