gan-style-harness

Habilidad de Arnés Estilo GAN

Inspirado en el Diseño de Arnés de Anthropic para Desarrollo de Aplicaciones de Larga Duración (24 de marzo de 2026)

Un arnés multiagente que separa la generación de la evaluación, creando un bucle de retroalimentación adversarial que impulsa la calidad mucho más allá de lo que un solo agente puede lograr.

Idea Central

Cuando se les pide que evalúen su propio trabajo, los agentes son optimistas patológicos — elogian resultados mediocres y se convencen de que los problemas legítimos no lo son. Pero diseñar un evaluador separado para que sea despiadadamente estricto es mucho más factible que enseñar a un generador a autocríticarse.

Esta es la misma dinámica que las GAN (Redes Generativas Antagónicas): el Generador produce, el Evaluador critica, y esa retroalimentación impulsa la siguiente iteración.

Cuándo Usarlo

• Construir aplicaciones completas a partir de un prompt de una línea
• Tareas de diseño frontend que requieren alta calidad visual
• Proyectos full-stack que necesitan funcionalidades funcionales, no solo código
• Cualquier tarea donde la estética "AI slop" sea inaceptable
• Proyectos donde quieras invertir $50-200 para obtener calidad de producción

Cuándo NO Usarlo

• Correcciones rápidas de un solo archivo (usa el claude -p estándar)
• Tareas con presupuesto ajustado (<$10)
• Refactorizaciones simples (usa el patrón de-sloppify en su lugar)
• Tareas que ya están bien especificadas con pruebas (usa el flujo de TDD)

Arquitectura

                    ┌─────────────┐
                    │  PLANIFICADOR│
                    │  (Sonnet)   │
                    └──────┬──────┘
                           │ Especificación del Producto
                           │ (características, sprints, dirección de diseño)
                           ▼
              ┌────────────────────────┐
              │                        │
              │   GENERADOR-EVALUADOR  │
              │    BUCLE DE RETROAL.   │
              │                        │
              │  ┌──────────┐          │
              │  │GENERADOR │--construye-->│──┐
              │  │ (Sonnet) │          │  │
              │  └────▲─────┘          │  │
              │       │                │  │ app en vivo
              │  retroalimentación     │  │
              │       │                │  │
              │  ┌────┴─────┐          │  │
              │  │EVALUADOR │<-prueba---│──┘
              │  │ (Sonnet) │          │
              │  │+Playwright│         │
              │  └──────────┘          │
              │                        │
              │   5-15 iteraciones     │
              └────────────────────────┘

Los Tres Agentes

1. Agente Planificador

Rol: Product manager — expande un prompt breve en una especificación completa del producto.

Comportamientos clave:

• Toma un prompt de una línea y produce una especificación de 16 características con múltiples sprints
• Define historias de usuario, requisitos técnicos y dirección de diseño visual
• Es deliberadamente ambicioso — la planificación conservadora lleva a resultados decepcionantes
• Produce criterios de evaluación que el Evaluador usará más tarde

Modelo: Sonnet por defecto; eleva mediante GAN_PLANNER_MODEL=opus para una expansión de especificaciones más profunda

2. Agente Generador

Rol: Desarrollador — implementa funcionalidades según la especificación.

Comportamientos clave:

• Trabaja en sprints estructurados (o modo continuo con modelos más nuevos)
• Negocia un "contrato de sprint" con el Evaluador antes de escribir código
• Usa herramientas full-stack: React, FastAPI/Express, bases de datos, CSS
• Gestiona git para control de versiones entre iteraciones
• Lee la retroalimentación del Evaluador y la incorpora en la siguiente iteración

Modelo: Sonnet por defecto; eleva mediante GAN_GENERATOR_MODEL=opus para máxima capacidad de codificación

3. Agente Evaluador

Rol: Ingeniero de QA — prueba la aplicación en vivo, no solo el código.

Comportamientos clave:

• Usa Playwright MCP para interactuar con la aplicación en vivo
• Hace clic en las funcionalidades, completa formularios, prueba puntos finales de API
• Puntúa según cuatro criterios (configurables):
  1. Calidad de Diseño — ¿Se siente como un todo coherente?
  2. Originalidad — ¿Decisiones personalizadas vs. patrones de plantilla/AI?
  3. Artesanía — ¿Tipografía, espaciado, animaciones, microinteracciones?
  4. Funcionalidad — ¿Todas las funcionalidades funcionan realmente?
• Devuelve retroalimentación estructurada con puntuaciones y problemas específicos
• Está diseñado para ser despiadadamente estricto — nunca elogia trabajos mediocres

Modelo: Sonnet por defecto; eleva mediante GAN_EVALUATOR_MODEL=opus para un juicio más fuerte y uso de herramientas

Criterios de Evaluación

Los cuatro criterios predeterminados, cada uno puntuado del 1 al 10:

## Rúbrica de Evaluación

### Calidad de Diseño (peso: 0.3)
- 1-3: Genérico, parecido a plantilla, estética "AI slop"
- 4-6: Competente pero sin brillo, sigue convenciones
- 7-8: Identidad visual distintiva y coherente
- 9-10: Podría pasar por el trabajo de un diseñador profesional

### Originalidad (peso: 0.2)
- 1-3: Colores predeterminados, diseños estándar, sin personalidad
- 4-6: Algunas elecciones personalizadas, mayormente patrones estándar
- 7-8: Visión creativa clara, enfoque único
- 9-10: Sorprendente, encantador, genuinamente novedoso

### Artesanía (peso: 0.3)
- 1-3: Diseños rotos, estados faltantes, sin animaciones
- 4-6: Funciona pero se siente tosco, espaciado inconsistente
- 7-8: Pulido, transiciones suaves, responsivo
- 9-10: Perfecto a nivel de píxel, microinteracciones encantadoras

### Funcionalidad (peso: 0.2)
- 1-3: Funcionalidades principales rotas o faltantes
- 4-6: El camino feliz funciona, los casos borde fallan
- 7-8: Todas las funcionalidades funcionan, buen manejo de errores
- 9-10: A prueba de balas, maneja todos los casos borde

Puntuación

• Puntuación ponderada = suma de (puntuación_criterio * peso)
• Umbral de aprobación = 7.0 (configurable)
• Iteraciones máximas = 15 (configurable, normalmente 5-15 son suficientes)

Uso

Mediante Comando

# Arnés completo de tres agentes
/project:gan-build "Construye una aplicación de gestión de proyectos con tableros Kanban, colaboración en equipo y modo oscuro"

# Con configuración personalizada
/project:gan-build "Construye una plataforma para compartir recetas" --max-iterations 10 --pass-threshold 7.5

# Modo de diseño frontend (solo generador + evaluador, sin planificador)
/project:gan-design "Crea una página de aterrizaje para un rastreador de portafolio de criptomonedas"

Mediante Script de Shell

# Uso básico
./scripts/gan-harness.sh "Construye un panel de control para streaming de música"

# Con opciones
GAN_MAX_ITERATIONS=10 \
GAN_PASS_THRESHOLD=7.5 \
GAN_EVAL_CRITERIA="functionality,performance,security" \
./scripts/gan-harness.sh "Construye una API REST para gestión de tareas"

Mediante Claude Code (Manual)

# Paso 1: Planificar
claude -p --model sonnet "Eres un Planificador de Producto. Lee PLANNER_PROMPT.md. Expande este resumen en una especificación completa del producto: 'Construye una app de tablero Kanban'. Escribe la especificación en spec.md"

# Paso 2: Generar (iteración 1)
claude -p --model sonnet "Eres un Generador. Lee spec.md. Implementa el Sprint 1. Inicia el servidor de desarrollo en el puerto 3000."

# Paso 3: Evaluar (iteración 1)
claude -p --model sonnet --allowedTools "Read,Bash,mcp__playwright__*" "Eres un Evaluador. Lee EVALUATOR_PROMPT.md. Prueba la app en vivo en http://localhost:3000. Puntúa según la rúbrica. Escribe la retroalimentación en feedback-001.md"

# Paso 4: Generar (iteración 2 — lee la retroalimentación)
claude -p --model sonnet "Eres un Generador. Lee spec.md y feedback-001.md. Aborda todos los problemas. Mejora las puntuaciones."

# Repite los pasos 3-4 hasta alcanzar el umbral de aprobación

Evolución a Través de las Capacidades del Modelo

El arnés debe simplificarse a medida que los modelos mejoran. Siguiendo la evolución de Anthropic:

Etapa 1 — Modelos más débiles (clase Sonnet)

• Se requiere descomposición completa en sprints
• Reinicios de contexto entre sprints (evitar ansiedad de contexto)
• Mínimo 2 agentes: Inicializador + Agente de Codificación
• Andamiaje pesado compensa las limitaciones del modelo

Etapa 2 — Modelos Capaces (clase Opus 4.5)

• Arnés completo de 3 agentes: Planificador + Generador + Evaluador
• Contratos de sprint antes de cada fase de implementación
• Descomposición en 10 sprints para aplicaciones complejas
• Reinicios de contexto aún útiles pero menos críticos

Etapa 3 — Modelos Frontera (clase Opus 4.6)

• Arnés simplificado: una sola pasada de planificación, generación continua
• Evaluación reducida a una sola pasada final (el modelo es más inteligente)
• No se necesita estructura de sprint
• La compactación automática maneja el crecimiento del contexto

Principio clave: Cada componente del arnés codifica una suposición sobre lo que el modelo no puede hacer solo. Cuando los modelos mejoran, vuelve a probar esas suposiciones. Elimina lo que ya no sea necesario.

Configuración

Variables de Entorno

Variable	Valor por Defecto	Descripción
GAN_MAX_ITERATIONS	15	Ciclos máximos generador-evaluador
GAN_PASS_THRESHOLD	7.0	Puntuación ponderada para aprobar (1-10)
GAN_PLANNER_MODEL	sonnet	Modelo para el agente planificador
GAN_GENERATOR_MODEL	sonnet	Modelo para el agente generador
GAN_EVALUATOR_MODEL	sonnet	Modelo para el agente evaluador
GAN_EVAL_CRITERIA	design,originality,craft,functionality	Criterios separados por comas
GAN_DEV_SERVER_PORT	3000	Puerto para la app en vivo
GAN_DEV_SERVER_CMD	npm run dev	Comando para iniciar el servidor de desarrollo
GAN_PROJECT_DIR	.	Directorio de trabajo del proyecto
GAN_SKIP_PLANNER	false	Omitir planificador, usar especificación directamente
GAN_EVAL_MODE	playwright	playwright, screenshot o code-only

Modos de Evaluación

Modo	Herramientas	Mejor Para
playwright	MCP del navegador + interacción en vivo	Aplicaciones full-stack con interfaz de usuario
screenshot	Captura de pantalla + análisis visual	Sitios estáticos, solo diseño
code-only	Pruebas + linting + compilación	APIs, librerías, herramientas CLI

Antipatrones

1. Evaluador demasiado indulgente — Si el evaluador aprueba todo en la iteración 1, tu rúbrica es demasiado generosa. Ajusta los criterios de puntuación y añade penalizaciones explícitas por patrones comunes de IA.

2. Generador ignorando la retroalimentación — Asegúrate de que la retroalimentación se pase como un archivo, no en línea. El generador debe leer feedback-NNN.md al inicio de cada iteración.

3. Bucles infinitos — Siempre establece GAN_MAX_ITERATIONS. Si el generador no puede mejorar por encima de una meseta de puntuación después de 3 iteraciones, detente y marca para revisión humana.

4. Evaluador probando superficialmente — El evaluador debe usar Playwright para interactuar con la app en vivo, no solo capturarla. Haz clic en botones, completa formularios, prueba estados de error.

5. Evaluador elogiando sus propias correcciones — Nunca permitas que el evaluador sugiera correcciones y luego evalúe esas correcciones. El evaluador solo critica; el generador corrige.

6. Agotamiento del contexto — Para sesiones largas, usa la compactación automática del SDK de Agente de Claude o reinicia el contexto entre fases importantes.

Resultados: Qué Esperar

Basado en los resultados publicados por Anthropic:

Métrica	Agente Solo	Arnés GAN	Mejora
Tiempo	20 min	4-6 horas	12-18x más largo
Costo	$9	$125-200	14-22x más
Calidad	Apenas funcional	Listo para producción	Cambio de fase
Funcionalidades principales	Rotas	Todas funcionando	N/A
Diseño	AI slop genérico	Distintivo, pulido	N/A

El equilibrio es claro: ~20x más tiempo y costo por un salto cualitativo en la calidad del resultado. Esto es para proyectos donde la calidad importa.

Referencias

• Anthropic: Diseño de Arnés para Aplicaciones de Larga Duración — Artículo original de Prithvi Rajasekaran
• Epsilla: El Bucle de Agente Estilo GAN — Deconstrucción de la arquitectura
• Martin Fowler: Ingeniería de Arnés — Contexto más amplio de la industria
• OpenAI: Ingeniería de Arnés — Trabajo paralelo de OpenAI