gan-style-harness

Skill : Harnais de Style GAN

Inspiré par Conception d'harnais d'Anthropic pour le développement d'applications longue durée (24 mars 2026)

Un harnais multi-agents qui sépare la génération de l'évaluation, créant une boucle de rétroaction antagoniste qui élève la qualité bien au-delà de ce qu'un seul agent peut accomplir.

Idée Centrale

Quand on leur demande d'évaluer leur propre travail, les agents sont des optimistes pathologiques — ils louent des résultats médiocres et se convainquent que les problèmes légitimes n'en sont pas. Mais concevoir un évaluateur séparé pour qu'il soit impitoyablement strict est bien plus accessible que d'apprendre à un générateur à s'auto-critiquer.

C'est la même dynamique que les GAN (Generative Adversarial Networks) : le Générateur produit, l'Évaluateur critique, et cette rétroaction alimente l'itération suivante.

Quand l'Utiliser

• Construire des applications complètes à partir d'une simple invite en une ligne.
• Tâches de conception frontend nécessitant une qualité visuelle élevée.
• Projets full-stack qui nécessitent des fonctionnalités opérationnelles, pas seulement du code.
• Toute tâche où l'esthétique « AI slop » est inacceptable.
• Projets où vous êtes prêt à investir 50 à 200 $ pour un résultat de qualité production.

Quand NE PAS l'Utiliser

• Corrections rapides d'un seul fichier (utiliser claude -p standard).
• Tâches avec des contraintes budgétaires serrées (<10 $).
• Refactoring simple (utiliser plutôt le pattern de-sloppify).
• Tâches déjà bien spécifiées avec des tests (utiliser le workflow TDD).

Architecture

                    ┌─────────────┐
                    │   PLANIFICATEUR   │
                    │  (Sonnet)    │
                    └──────┬──────┘
                           │ Cahier des charges
                           │ (fonctionnalités, sprints, direction design)
                           ▼
              ┌────────────────────────┐
              │                        │
              │   GÉNÉRATEUR-ÉVALUATEUR   │
              │     BOUCLE DE RÉTROACTION    │
              │                        │
              │  ┌──────────┐          │
              │  │GÉNÉRATEUR │--construit-->│──┐
              │  │ (Sonnet) │          │  │
              │  └────▲─────┘          │  │
              │       │                │  │ app live
              │    rétroaction          │  │
              │       │                │  │
              │  ┌────┴─────┐          │  │
              │  │ÉVALUATEUR │<-teste----│──┘
              │  │ (Sonnet) │          │
              │  │+Playwright│         │
              │  └──────────┘          │
              │                        │
              │   5-15 itérations      │
              └────────────────────────┘

Les Trois Agents

1. Agent Planificateur

Rôle : Chef de produit — transforme une invite brève en un cahier des charges complet.

Comportements clés :

• Prend une invite d'une ligne et produit un cahier des charges multi-sprints avec 16 fonctionnalités.
• Définit les user stories, les exigences techniques et la direction du design visuel.
• Est délibérément ambitieux — une planification conservatrice mène à des résultats décevants.
• Produit les critères d'évaluation que l'Évaluateur utilisera plus tard.

Modèle : Sonnet par défaut ; passez à GAN_PLANNER_MODEL=opus pour une expansion plus approfondie.

2. Agent Générateur

Rôle : Développeur — implémente les fonctionnalités selon le cahier des charges.

Comportements clés :

• Travaille en sprints structurés (ou en mode continu avec les modèles plus récents).
• Négocie un « contrat de sprint » avec l'Évaluateur avant d'écrire du code.
• Utilise une stack full-stack : React, FastAPI/Express, bases de données, CSS.
• Gère git pour le contrôle de version entre les itérations.
• Lit la rétroaction de l'Évaluateur et l'incorpore dans l'itération suivante.

Modèle : Sonnet par défaut ; passez à GAN_GENERATOR_MODEL=opus pour une capacité de codage maximale.

3. Agent Évaluateur

Rôle : Ingénieur QA — teste l'application live, pas seulement le code.

Comportements clés :

• Utilise Playwright MCP pour interagir avec l'application en direct.
• Parcourt les fonctionnalités, remplit des formulaires, teste les points d'accès API.
• Note selon quatre critères (configurables) :
  1. Qualité du Design — L'ensemble est-il cohérent ?
  2. Originalité — Décisions personnalisées vs motifs de template/AI ?
  3. Finition — Typographie, espacement, animations, micro-interactions ?
  4. Fonctionnalité — Toutes les fonctionnalités marchent-elles vraiment ?
• Renvoie une rétroaction structurée avec des scores et des problèmes spécifiques.
• Est conçu pour être impitoyablement strict — ne félicite jamais un travail médiocre.

Modèle : Sonnet par défaut ; passez à GAN_EVALUATOR_MODEL=opus pour un jugement plus fort et une utilisation d'outils.

Critères d'Évaluation

Les quatre critères par défaut, notés de 1 à 10 :

## Grille d'Évaluation

### Qualité du Design (poids : 0.3)
- 1-3 : Générique, semblable à un template, esthétique « AI slop ».
- 4-6 : Compétent mais sans originalité, suit les conventions.
- 7-8 : Identité visuelle distinctive et cohérente.
- 9-10 : Pourrait passer pour le travail d'un designer professionnel.

### Originalité (poids : 0.2)
- 1-3 : Couleurs par défaut, mises en page standard, pas de personnalité.
- 4-6 : Quelques choix personnalisés, motifs majoritairement standards.
- 7-8 : Vision créative claire, approche unique.
- 9-10 : Surprenant, charmant, véritablement novateur.

### Finition (poids : 0.3)
- 1-3 : Mises en page cassées, états manquants, pas d'animations.
- 4-6 : Fonctionne mais semble rugueux, espacement incohérent.
- 7-8 : Soigné, transitions fluides, responsive.
- 9-10 : Parfait au pixel près, micro-interactions charmantes.

### Fonctionnalité (poids : 0.2)
- 1-3 : Fonctionnalités principales cassées ou manquantes.
- 4-6 : Le parcours heureux fonctionne, les cas limites échouent.
- 7-8 : Toutes les fonctionnalités marchent, bonne gestion des erreurs.
- 9-10 : Infaillible, gère tous les cas limites.

Notation

• Score pondéré = somme de (score_critère * poids).
• Seuil de réussite = 7.0 (configurable).
• Nombre maximal d'itérations = 15 (configurable, 5 à 15 suffisent généralement).

Utilisation

Via Commande

# Harnais complet à trois agents
/project:gan-build "Construis une application de gestion de projet avec des tableaux Kanban, une collaboration d'équipe et un mode sombre"

# Avec configuration personnalisée
/project:gan-build "Construis une plateforme de partage de recettes" --max-iterations 10 --pass-threshold 7.5

# Mode design frontend (générateur + évaluateur uniquement, pas de planificateur)
/project:gan-design "Crée une page d'accueil pour un tracker de portefeuille crypto"

Via Script Shell

# Utilisation de base
./scripts/gan-harness.sh "Construis un tableau de bord de streaming musical"

# Avec options
GAN_MAX_ITERATIONS=10 \
GAN_PASS_THRESHOLD=7.5 \
GAN_EVAL_CRITERIA="functionality,performance,security" \
./scripts/gan-harness.sh "Construis une API REST pour la gestion de tâches"

Via Claude Code (Manuel)

# Étape 1 : Planifier
claude -p --model sonnet "Tu es un Planificateur Produit. Lis PLANNER_PROMPT.md. Développe cette brève en un cahier des charges complet : 'Construis une application de tableau Kanban'. Écris le cahier des charges dans spec.md"

# Étape 2 : Générer (itération 1)
claude -p --model sonnet "Tu es un Générateur. Lis spec.md. Implémente le Sprint 1. Démarre le serveur de développement sur le port 3000."

# Étape 3 : Évaluer (itération 1)
claude -p --model sonnet --allowedTools "Read,Bash,mcp__playwright__*" "Tu es un Évaluateur. Lis EVALUATOR_PROMPT.md. Teste l'application live à http://localhost:3000. Note selon la grille. Écris la rétroaction dans feedback-001.md"

# Étape 4 : Générer (itération 2 — lit la rétroaction)
claude -p --model sonnet "Tu es un Générateur. Lis spec.md et feedback-001.md. Résous tous les problèmes. Améliore les scores."

# Répéter les étapes 3-4 jusqu'à ce que le seuil de réussite soit atteint

Évolution selon les Capacités des Modèles

Le harnais doit se simplifier à mesure que les modèles s'améliorent. Suivant l'évolution d'Anthropic :

Étape 1 — Modèles plus faibles (classe Sonnet)

• Décomposition complète en sprints requise.
• Réinitialisations de contexte entre les sprints (éviter l'anxiété de contexte).
• Minimum 2 agents : Initialiseur + Agent de codage.
• Échafaudage lourd pour compenser les limites du modèle.

Étape 2 — Modèles capables (classe Opus 4.5)

• Harnais complet à 3 agents : Planificateur + Générateur + Évaluateur.
• Contrats de sprint avant chaque phase d'implémentation.
• Décomposition en 10 sprints pour les applications complexes.
• Réinitialisations de contexte encore utiles mais moins critiques.

Étape 3 — Modèles de pointe (classe Opus 4.6)

• Harnais simplifié : une seule passe de planification, génération continue.
• Évaluation réduite à une seule passe finale (le modèle est plus intelligent).
• Aucune structure de sprint nécessaire.
• La compaction automatique gère la croissance du contexte.

Principe clé : Chaque composant du harnais encode une hypothèse sur ce que le modèle ne peut pas faire seul. Quand les modèles s'améliorent, retestez ces hypothèses. Supprimez ce qui n'est plus nécessaire.

Configuration

Variables d'Environnement

Variable	Défaut	Description
GAN_MAX_ITERATIONS	15	Cycles maximum générateur-évaluateur
GAN_PASS_THRESHOLD	7.0	Score pondéré pour réussir (1-10)
GAN_PLANNER_MODEL	sonnet	Modèle pour l'agent planificateur
GAN_GENERATOR_MODEL	sonnet	Modèle pour l'agent générateur
GAN_EVALUATOR_MODEL	sonnet	Modèle pour l'agent évaluateur
GAN_EVAL_CRITERIA	design,originality,craft,functionality	Critères séparés par des virgules
GAN_DEV_SERVER_PORT	3000	Port pour l'application live
GAN_DEV_SERVER_CMD	npm run dev	Commande pour démarrer le serveur de développement
GAN_PROJECT_DIR	.	Répertoire de travail du projet
GAN_SKIP_PLANNER	false	Ignorer le planificateur, utiliser directement le cahier des charges
GAN_EVAL_MODE	playwright	playwright, screenshot ou code-only

Modes d'Évaluation

Mode	Outils	Meilleur Pour
playwright	MCP navigateur + interaction live	Applications full-stack avec UI
screenshot	Capture d'écran + analyse visuelle	Sites statiques, design uniquement
code-only	Tests + linting + build	API, bibliothèques, outils CLI

Anti-Patterns

1. Évaluateur trop indulgent — Si l'évaluateur approuve tout dès l'itération 1, votre grille est trop généreuse. Resserrez les critères de notation et ajoutez des pénalités explicites pour les motifs AI courants.

2. Générateur ignorant la rétroaction — Assurez-vous que la rétroaction est passée sous forme de fichier, pas en ligne. Le générateur doit lire feedback-NNN.md au début de chaque itération.

3. Boucles infinies — Définissez toujours GAN_MAX_ITERATIONS. Si le générateur ne peut plus s'améliorer après un plateau de score de 3 itérations, arrêtez-vous et signalez-le pour révision humaine.

4. Évaluateur testant superficiellement — L'évaluateur doit utiliser Playwright pour interagir avec l'application live, pas seulement en faire une capture d'écran. Cliquez sur les boutons, remplissez les formulaires, testez les états d'erreur.

5. Évaluateur louant ses propres corrections — Ne laissez jamais l'évaluateur suggérer des corrections puis évaluer ces mêmes corrections. L'évaluateur ne fait que critiquer ; le générateur corrige.

6. Épuisement du contexte — Pour les sessions longues, utilisez la compaction automatique du SDK Agent Claude ou réinitialisez le contexte entre les phases majeures.

Résultats : À Quoi s'Attendre

D'après les résultats publiés par Anthropic :

Métrique	Agent Solo	Harnais GAN	Amélioration
Temps	20 min	4-6 heures	12-18x plus long
Coût	9 $	125-200 $	14-22x plus
Qualité	À peine fonctionnel	Prêt pour la production	Changement de phase
Fonctionnalités principales	Cassées	Toutes opérationnelles	N/A
Design	AI slop générique	Distinctif, soigné	N/A

Le compromis est clair : environ 20x plus de temps et de coût pour un saut qualitatif dans la qualité des résultats. C'est pour les projets où la qualité compte.

Références

• Anthropic : Conception d'harnais pour les applications longue durée — Article original de Prithvi Rajasekaran
• Epsilla : La boucle d'agent de style GAN — Déconstruction de l'architecture
• Martin Fowler : Ingénierie des harnais — Contexte industriel plus large
• OpenAI : Ingénierie des harnais — Travail parallèle d'OpenAI