gan-style-harness

Compétence Harnais Style GAN

Inspiré par la Conception de Harnais d'Anthropic pour le Développement d'Applications Longues (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 atteindre.

Idée Centrale

Lorsqu'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 des problèmes légitimes n'en sont pas. Mais il est bien plus simple de programmer un évaluateur séparé pour qu'il soit impitoyablement strict que d'apprendre à un générateur à s'auto-critiquer.

C'est la même dynamique que les GANs (Réseaux Antagonistes Génératifs) : 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 ligne de commande
• Tâches de conception frontend nécessitant une haute qualité visuelle
• Projets full-stack nécessitant des fonctionnalités opérationnelles, pas seulement du code
• Toute tâche où l'esthétique « bâclée par IA » est inacceptable
• Projets où vous êtes prêt à investir 50 à 200 dollars pour un résultat de qualité professionnelle

Quand NE PAS l'Utiliser

• Corrections rapides de fichiers uniques (utiliser la commande standard claude -p)
• Tâches avec des contraintes budgétaires serrées (moins de 10 dollars)
• Refactorisations simples (utiliser plutôt le modèle « de-sloppify »)
• Tâches déjà bien spécifiées avec des tests (utiliser le workflow TDD)

Architecture

                    ┌─────────────┐
                    │   PLANNER   │
                    │  (Sonnet)   │
                    └──────┬──────┘
                           │ Spécification Produit
                           │ (fonctionnalités, sprints, direction design)
                           ▼
              ┌────────────────────────┐
              │                        │
              │   GÉNÉRATEUR-ÉVALUATEUR│
              │    BOUCLE DE RETOUR    │
              │                        │
              │  ┌──────────┐          │
              │  │GÉNÉRATEUR│--construit──>│──┐
              │  │ (Sonnet) │          │  │
              │  └────▲─────┘          │  │
              │       │                │  │ app en direct
              │    retour              │  │
              │       │                │  │
              │  ┌────┴─────┐          │  │
              │  │ÉVALUATEUR│<-test----│──┘
              │  │ (Sonnet) │          │
              │  │+Playwright│         │
              │  └──────────┘          │
              │                        │
              │   5-15 itérations      │
              └────────────────────────┘

Les Trois Agents

1. Agent Planificateur

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

Comportements clés :

• Prend une ligne de commande et produit une spécification multi-fonctionnalités, multi-sprints
• Définit les histoires utilisateur, 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 ; élever via GAN_PLANNER_MODEL=opus pour une expansion plus approfondie des spécifications

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 la pile full-stack : React, FastAPI/Express, bases de données, CSS
• Gère git pour le contrôle de version entre les itérations
• Lit les retours de l'Évaluateur et les intègre à l'itération suivante

Modèle : Sonnet par défaut ; élever via GAN_GENERATOR_MODEL=opus pour une capacité de codage maximale

3. Agent Évaluateur

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

Comportements clés :

• Utilise le MCP Playwright 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é de Conception — L'ensemble est-il cohérent ?
  2. Originalité — Décisions personnalisées vs. motifs template/IA ?
  3. Finition — Typographie, espacement, animations, micro-interactions ?
  4. Fonctionnalité — Toutes les fonctionnalités marchent-elles vraiment ?
• Retourne des retours structurés 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 ; élever via GAN_EVALUATOR_MODEL=opus pour un jugement plus fort et une utilisation d'outils accrue

Critères d'Évaluation

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

## Rubrique d'Évaluation

### Qualité de Conception (poids: 0.3)
- 1-3 : Générique, ressemble à un template, esthétique « bâclée par IA »
- 4-6 : Compétent mais sans intérêt, 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, aucune personnalité
- 4-6 : Quelques choix personnalisés, surtout des motifs standards
- 7-8 : Vision créative claire, approche unique
- 9-10 : Surprenant, délicieux, véritablement novateur

### Finition (poids: 0.3)
- 1-3 : Mises en page cassées, états manquants, pas d'animations
- 4-6 : Fonctionne mais semble brut, espacement incohérent
- 7-8 : Poli, transitions fluides, responsive
- 9-10 : Pixel-perfect, micro-interactions délicieuses

### Fonctionnalité (poids: 0.2)
- 1-3 : Fonctionnalités principales cassées ou manquantes
- 4-6 : Le chemin heureux fonctionne, les cas limites échouent
- 7-8 : Toutes les fonctionnalités fonctionnent, 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, généralement 5 à 15 suffisent)

Utilisation

Via la 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 conception 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 un Script Shell

# Utilisation basique
./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 demande 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 en direct à l'adresse http://localhost:3000. Note-la selon la rubrique. Écris les retours dans feedback-001.md"

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

# Répéter les étapes 3 et 4 jusqu'à atteindre le seuil de réussite

Évolution avec 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éinitialisation du contexte entre les sprints (éviter l'anxiété de contexte)
• Minimum de 2 agents : Initialisateur + Agent de codage
• Échafaudage important pour compenser les limitations 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éinitialisation du contexte toujours utile mais moins critique

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

• Harnais simplifié : une seule phase de planification, génération continue
• Évaluation réduite à un seul passage final (le modèle est plus intelligent)
• Aucune structure de sprint nécessaire
• Compactage automatique pour gérer 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. Lorsque les modèles s'améliorent, testez à nouveau ces hypothèses. Supprimez ce qui n'est plus nécessaire.

Configuration

Variables d'Environnement

Variable	Défaut	Description
GAN_MAX_ITERATIONS	15	Nombre maximal de cycles 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 en direct
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 en direct	Applications full-stack avec UI
screenshot	Capture d'écran + analyse visuelle	Sites statiques, design uniquement
code-only	Tests + linting + build	APIs, bibliothèques, outils CLI

Anti-Patterns

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

2. Générateur ignorant les retours — Assurez-vous que les retours sont passés 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 — Toujours définir GAN_MAX_ITERATIONS. Si le générateur ne peut plus améliorer le score après 3 itérations, arrêtez-vous et signalez-le pour une révision humaine.

4. Évaluateur testant superficiellement — L'évaluateur doit utiliser Playwright pour interagir avec l'application en direct, 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 corrections. L'évaluateur ne fait que critiquer ; le générateur corrige.

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

Résultats : À Quoi S'attendre

Basé sur les résultats publiés par Anthropic :

Métrique	Agent Seul	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	Bâclé générique IA	Distinctif, poli	N/A

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

Références

• Anthropic : Conception de Harnais pour les Applications Longues — Article original par Prithvi Rajasekaran (en anglais)
• Epsilla : La Boucle d'Agent Style GAN — Déconstruction de l'architecture (en anglais)
• Martin Fowler : Ingénierie de Harnais — Contexte plus large de l'industrie (en anglais)
• OpenAI : Ingénierie de Harnais — Travail parallèle d'OpenAI (en anglais)