$ ~/registry/skill/affaan-m-gan-style-harness

SKILL

gan-style-harness

Name: gan-style-harness
Author: affaan-m

Autonomously build higher-quality apps through iterative generator-evaluator agent workflows.

Stars

★ 229,796

Source

GitHub

Updated

2026-07-15

// securityLow risk

Prompt only, no code
Open source
Community-trusted· 229.8k

Running security audit…

Credentials
Network egress
Code execution
Data access
Supply chain

// install

Copy the install command and let the AI configure it · recommended for beginners

Please install the "gan-style-harness" skill from askskill:
1. Download https://raw.githubusercontent.com/affaan-m/ECC/main/skills/gan-style-harness/SKILL.md
2. Save it as ~/.claude/skills/gan-style-harness/SKILL.md
3. Reload skills and tell me it's ready

// download

Download SKILL.mdInstall manifest ↗

// examples

Generate an app prototype automatically

Prompt

Use a generator-evaluator workflow to create a development plan for a team task management web app. First output requirements, tech stack, and system architecture, then generate frontend and backend code scaffolds. After each round, self-evaluate usability, maintainability, and risks, iterate for 3 rounds, and present the final version.

Expected

An iteratively improved app package including requirements, architecture, code scaffolds, and revision notes.

Improve code quality

Prompt

Here is a Node.js API implementation in progress. Treat it as the generator's first draft, then switch to the evaluator role to score it across correctness, error handling, performance, security, and testability, identify issues, return to the generator role to fix them, repeat for two rounds, and output the final code with evaluation results.

Expected

Higher-quality revised code plus round-by-round evaluations and fix logs.

Plan an autonomous development workflow

Prompt

Design an autonomous development workflow for an AI startup using a generator-evaluator harness to continuously ship new features. Define role responsibilities, input/output formats, quality gates, rollback mechanisms, and human intervention points, then provide an executable workflow template.

Expected

A practical autonomous development workflow design for standardized team iteration.

// docs

GAN-Style Harness Skill

Inspired by Anthropic's Harness Design for Long-Running Application Development (March 24, 2026)

A multi-agent harness that separates generation from evaluation, creating an adversarial feedback loop that drives quality far beyond what a single agent can achieve.

Core Insight

When asked to evaluate their own work, agents are pathological optimists — they praise mediocre output and talk themselves out of legitimate issues. But engineering a separate evaluator to be ruthlessly strict is far more tractable than teaching a generator to self-critique.

This is the same dynamic as GANs (Generative Adversarial Networks): the Generator produces, the Evaluator critiques, and that feedback drives the next iteration.

When to Use

Building complete applications from a one-line prompt
Frontend design tasks requiring high visual quality
Full-stack projects that need working features, not just code
Any task where "AI slop" aesthetics are unacceptable
Projects where you want to invest $50-200 for production-quality output

When NOT to Use

Quick single-file fixes (use standard claude -p)
Tasks with tight budget constraints (<$10)
Simple refactoring (use de-sloppify pattern instead)
Tasks that are already well-specified with tests (use TDD workflow)

Architecture

                    ┌─────────────┐
                    │   PLANNER   │
                    │  (Opus 4.6) │
                    └──────┬──────┘
                           │ Product Spec
                           │ (features, sprints, design direction)
                           ▼
              ┌────────────────────────┐
              │                        │
              │   GENERATOR-EVALUATOR  │
              │      FEEDBACK LOOP     │
              │                        │
              │  ┌──────────┐          │
              │  │GENERATOR │--build-->│──┐
              │  │(Opus 4.6)│          │  │
              │  └────▲─────┘          │  │
              │       │                │  │ live app
              │    feedback             │  │
              │       │                │  │
              │  ┌────┴─────┐          │  │
              │  │EVALUATOR │<-test----│──┘
              │  │(Opus 4.6)│          │
              │  │+Playwright│         │
              │  └──────────┘          │
              │                        │
              │   5-15 iterations      │
              └────────────────────────┘

The Three Agents

1. Planner Agent

Role: Product manager — expands a brief prompt into a full product specification.

Key behaviors:

Takes a one-line prompt and produces a 16-feature, multi-sprint specification
Defines user stories, technical requirements, and visual design direction
Is deliberately ambitious — conservative planning leads to underwhelming results
Produces evaluation criteria that the Evaluator will use later

Model: Opus 4.6 (needs deep reasoning for spec expansion)

2. Generator Agent

Role: Developer — implements features according to the spec.

Key behaviors:

Works in structured sprints (or continuous mode with newer models)
Negotiates a "sprint contract" with the Evaluator before writing code
Uses full-stack tooling: React, FastAPI/Express, databases, CSS
Manages git for version control between iterations
Reads Evaluator feedback and incorporates it in next iteration

Model: Opus 4.6 (needs strong coding capability)

3. Evaluator Agent

Role: QA engineer — tests the live running application, not just code.

Key behaviors:

Uses Playwright MCP to interact with the live application
Clicks through features, fills forms, tests API endpoints
Scores against four criteria (configurable):
1. Design Quality — Does it feel like a coherent whole?
2. Originality — Custom decisions vs. template/AI patterns?

…

View full docs ↗