GAN Loop

Der erste Entwurf deiner KI ist zuversichtlicher Schrott. Jedes Mal.

Nicht weil das Modell schlecht ist. Weil es niemanden gibt, der zurückschlägt.

Füge einen zweiten Agenten hinzu, dessen einziger Job es ist, den ersten auseinanderzunehmen, und plötzlich konvergiert Qualität in 2 Durchläufen. Dieses Muster heißt GAN Loop. Hier ist die vollständige Implementierungsanleitung.

Was ist ein GAN Loop?

GAN steht für Generative Adversarial Network. Im traditionellen maschinellen Lernen konkurrieren zwei neuronale Netze: Ein Generator erstellt gefälschte Bilder, ein Diskriminator versucht die Fakes zu erkennen. Sie trainieren sich gegenseitig, bis der Generator gut genug ist, um den Diskriminator zu täuschen.

Wir wenden dieselbe Idee auf KI-Agenten an. Keine neuronalen Netze nötig. Nur zwei Claude-Instanzen mit unterschiedlichen Jobs und ein Loop, der läuft, bis der Output einen Qualitätsschwellenwert erreicht.

Generator erstellt. Evaluator beurteilt. Generator verbessert. Wiederholen bis der Score nicht mehr steigt.

Das Problem, das es löst

Frage eine einzelne KI, etwas zu schreiben. Sie produziert einen Output, der vernünftig aussieht. Strukturiert. Zuversichtlich.

Dann schau genauer hin. Der Hook ist generisch. Die Zahlen sind vage. Der CTA könnte auf alles zutreffen. Die KI hatte keinen externen Druck, also hat sie für "sieht gut aus beim ersten Lesen" optimiert statt für "performt wirklich."

Die KI weiß nicht, was sie nicht weiß. Sie kann ihre eigenen blinden Flecken nicht bewerten.

Ein zweiter Agent, der den Output kalt mit einer Rubrik in der Hand liest, findet alles, was der Generator übersehen hat. Und er gibt spezifisches, umsetzbares Feedback, weil das sein einziger Job ist.

Die zwei Agenten

Jeder GAN Loop hat genau zwei Rollen. Sie dürfen niemals derselbe Agent sein.

Der Generator hat vollen Kontext, Tools und kreative Fähigkeiten. Er produziert den bestmöglichen Output basierend auf dem Brief. Er sieht die Bewertungsrubrik NICHT im Voraus. Ihm die Rubrik zu geben veranlasst ihn, für die Rubrik zu optimieren statt für echte Qualität, was den ganzen Punkt zunichte macht.

Der Evaluator hat die Rubrik und den Output. Das war's. Keine Erinnerung an den Generierungsprozess. Keine emotionale Investition in den Entwurf. Er liest kalt, bewertet jede Dimension mit Begründung und gibt ein strukturiertes Urteil zurück: accept, refine oder reject. Wenn er ablehnt, gibt er genaue Zitate aus dem Output, erklärt das Problem und liefert ein konkretes Rewrite.

Diese Trennung ist alles. Der Generator ist von Natur aus optimistisch. Der Evaluator ist durch Design adversarisch. Keine Rolle funktioniert gut, wenn derselbe Agent beide spielt.

Die Agent-Definitionen

Hier sind die zwei Agent-Dateien, die du brauchst. Speichere sie in .claude/agents/ in deinem Projekt.

Der Generator-Agent

---
name: gan-generator
description: "GAN Harness — Generator agent. Creates output according to the brief, reads evaluator feedback, and iterates until quality threshold is met."
tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"]
model: claude-sonnet-4-6
---

You are the Generator in a GAN-style multi-agent harness.

## Your Role

You are the Creator. You build the output according to the spec.
After each iteration, the Evaluator will score your work.
You then read the feedback and improve.

## Key Rules

1. Read the spec first — always start by reading the brief or spec file
2. Read feedback — before each iteration (except the first), read the latest feedback file
3. Address every issue — feedback items are not suggestions, fix them all
4. Do not self-evaluate — your job is to create, not to judge
5. Commit between iterations — so the Evaluator sees clean diffs

## Workflow

### First Iteration
1. Read the brief / spec
2. Produce the output (post, code, design, document — whatever is specified)
3. Write generator-state.md: what you built, known issues, open questions

### Subsequent Iterations
1. Read feedback/feedback-NNN.md (latest)
2. List every issue the Evaluator raised
3. Fix by priority: critical issues first, then major, then minor
4. Update generator-state.md

## Generator State File

Write to generator-state.md after each iteration:

# Generator State — Iteration NNN

## What Was Built
- [output 1]
- [output 2]

## What Changed This Iteration
- Fixed: [issue from feedback]
- Improved: [aspect that scored low]

## Known Issues
- [anything you could not fix]

Der Evaluator-Agent

---
name: gan-evaluator
description: "GAN Harness — Evaluator agent. Scores output against rubric, provides actionable feedback to the Generator. Be ruthlessly strict."
tools: ["Read", "Write", "Grep", "Glob"]
model: claude-sonnet-4-6
---

You are the Evaluator in a GAN-style multi-agent harness.

## Your Role

You are the Critic. You score the Generator's output against a strict rubric
and provide detailed, actionable feedback.

## Core Principle: Be Ruthlessly Strict

> You are NOT here to be encouraging. You are here to find every flaw.
> A passing score must mean the output is genuinely good — not "good for an AI."

Your natural tendency is to be generous. Fight it:
- Do NOT say "overall good effort" — this is cope
- Do NOT talk yourself out of issues you found ("it's minor, probably fine")
- Do NOT give points for effort or potential
- DO penalize heavily for vague claims, AI slop patterns, and missing specifics
- DO compare against what a professional human would ship

## Evaluation Workflow

### Step 1: Read the Rubric
Read the criteria file for this task type.
Read the spec / brief for what was asked.
Read generator-state.md for what was built.

### Step 2: Score

Score each criterion on a 1-10 scale using the rubric file.

Calibration:
- 1-3: Broken or embarrassing
- 4-5: Functional but clearly AI-generated
- 6: Decent but unremarkable
- 7: Good — solid work
- 8: Very good — professional quality
- 9: Excellent — polished, senior quality
- 10: Exceptional — ships as-is

### Step 3: Write Feedback

Write to feedback/feedback-NNN.md:

# Evaluation — Iteration NNN

## Scores

| Criterion | Score | Weight | Weighted |
|-----------|-------|--------|----------|
| [criterion] | X/10 | 0.X | X.X |
| TOTAL | | | X.X/10 |

## Verdict: PASS / FAIL (threshold: 7.0)

## Critical Issues (must fix)
1. [Issue]: [exact quote] → [how to fix]

## Major Issues (should fix)
1. [Issue]: [exact quote] → [how to fix]

## Minor Issues (nice to fix)
1. [Issue]: [exact quote] → [how to fix]

## What Improved Since Last Iteration
- [improvement]

## Feedback Quality Rules

1. Every issue must have a concrete "how to fix" — not just "this is bad"
2. Reference specific elements — not "the hook needs work" but quote the exact text
3. Quantify when possible — "3 out of 5 items have no concrete numbers"
4. Acknowledge genuine improvements — calibrates the loop

Die Loop-Konfiguration

Speichere das als gan.json in deinem Projekt (oder im .claude/-Ordner):

{
  "default_threshold": 7.0,
  "max_iterations": 3,
  "escalation": "accept-with-notes",

  "profiles": {
    "my-task": {
      "generator": {
        "agent": "gan-generator",
        "skills": ["relevant-skill-here"]
      },
      "evaluator": {
        "agent": "gan-evaluator",
        "criteria_file": "evaluator/my-task-criteria.md"
      },
      "scoring": {
        "dimensions": [
          {"name": "hook_power",     "weight": 0.25},
          {"name": "value_density",  "weight": 0.25},
          {"name": "brand_voice",    "weight": 0.20},
          {"name": "clarity",        "weight": 0.20},
          {"name": "cta",            "weight": 0.10}
        ],
        "threshold": 7.0,
        "max_iterations": 3
      },
      "sprint_contract": [
        "Each item here is a binary gate check that must pass before shipping",
        "Example: hook lands before 210-char cutoff",
        "Example: no forbidden words",
        "Example: all claims verified against source of truth"
      ]
    }
  }
}

Der sprint_contract ist eine Liste binärer Pass/Fail-Regeln. Der Evaluator prüft diese zuerst, noch bevor er den gewichteten Score berechnet. Ein einziger fehlgeschlagener Gate bedeutet reject, egal wie gut der Rest ist.

Wie eine echte Rubrik aussieht

Der Evaluator ist nur so gut wie seine Rubrik. Vage Kriterien produzieren vage Scores.

Eine echte Rubrik definiert jede Dimension mit drei Anker-Beispielen: außergewöhnlich (9-10), akzeptabel (6-7) und ablehnen (1-4). Jeder Anker enthält ein Beispiel UND einen Grund, damit der Evaluator über Iterationen hinweg konsistent kalibrieren kann.

Hier ist die Hook-Power-Dimension aus der LinkedIn-Post-Rubrik:

### Hook Power (weight: 0.20)

What you're measuring: Would this stop a busy professional from scrolling?
Must land before the 210-character cutoff.

Score 9-10 (Exceptional):
  "I was quoted $15,000 for an MVP. I built it for $197 in a weekend."
  Why: Specific dollar amounts, unexpected contrast, lands in 67 characters.
  Personal stake. Reader wants to know how.

Score 6-7 (Acceptable):
  "Building a SaaS doesn't have to take months. Here's a faster way."
  Why: Clear promise but no specificity, no numbers, no personal stake.

Score 1-4 (Reject):
  "In today's rapidly evolving tech landscape, AI is changing everything."
  Why: Generic, forbidden phrase, says nothing unique. Reader scrolls past.

Die Anker-Beispiele sind der wichtigste Teil. Ohne sie werden zwei Bewertungen desselben Outputs ihn jedes Mal anders bewerten. Mit ihnen bleiben Scores über Iterationen konsistent, was den Loop zum Konvergieren bringt.

Ein echtes Beispiel: Loop für Loop

Hier ist ein LinkedIn-Post, der 3 Runden durchläuft.

Brief: Schreibe einen LinkedIn-Post darüber, wie Build This Now 18 KI-Agenten nutzt, um SaaS-Features zu bauen.

Loop 1 — Generator läuft kalt:

In today's fast-paced world of software development, AI is completely
changing how we build products. Our innovative platform leverages
cutting-edge AI agents to help you build your SaaS faster and
more efficiently than ever before.

#AI #SaaS #startup #tech #innovation

Evaluator bewertet Loop 1:

DIMENSION SCORES:
- hook_power:           2/10 — forbidden phrase opener, zero specificity
- value_density:        2/10 — no concrete information in any sentence
- brand_alignment:      2/10 — "innovative", "cutting-edge" are banned words
- platform_optimization: 3/10 — 5 hashtags OK but no character discipline
- cta_effectiveness:    1/10 — no CTA present

OVERALL: 2.1/10

GATE CHECKS:
- No forbidden words: FAIL ("cutting-edge", "innovative", "fast-paced world")
- Single clear CTA: FAIL

VERDICT: reject

CRITICAL ISSUES:
1. Hook: "In today's fast-paced world" → forbidden phrase, replace with
   a specific personal story or data point. Example:
   "I rebuilt auth and payments 3 times in 2 years. Same 3-week slog. Every time."

Loop 2 — Generator verarbeitet Feedback:

I spent 3 weekends rebuilding the same auth and payments system.

With Build This Now, I describe the feature. 9 AI agents take over:
database architect designs the tables, backend developer writes the
API, designer builds the UI, tester catches the bugs.

One feature, 10-60 minutes. No more rebuilt boilerplate.

What are you still building by hand that you shouldn't be?

#BuildThisNow #indiehacker #buildinpublic #solofounder #SaaS

Evaluator bewertet Loop 2:

DIMENSION SCORES:
- hook_power:           7/10 — personal, relatable, but "I spent 3 weekends"
                               is passive. "3 weekends" needs more punch.
- value_density:        8/10 — concrete agent names, real time range
- brand_alignment:      8/10 — on-brand, hashtag count correct
- platform_optimization: 8/10 — good length, hashtags at end
- cta_effectiveness:    8/10 — question CTA invites comment

OVERALL: 7.7/10

GATE CHECKS: all pass

VERDICT: refine

MAJOR ISSUES:
1. Hook: "I spent 3 weekends" is weak. The data point "3 weekends" is good
   but "spent" is passive. Rewrite opener to front-load the pain with
   a harder verb. Example:
   "I rebuilt auth and payments 3 times in 2 years. Same 3-week slog. Every time."

Loop 3 — Eine gezielte Korrektur:

I rebuilt auth and payments 3 times in 2 years. Same 3-week slog. Every time.

Then I described the feature in plain English and watched 9 AI agents
build it in 45 minutes: database, API, UI, tests. All wired. All clean.

Build This Now ships what used to take a week, in an afternoon.

What are you still rebuilding by hand?

#BuildThisNow #indiehacker #buildinpublic #solofounder #SaaS

Evaluator bewertet Loop 3:

DIMENSION SCORES:
- hook_power:           9/10 — "3 times in 2 years" is specific and damning
- value_density:        9/10 — every sentence adds new information
- brand_alignment:      9/10 — BTN voice, correct claims
- platform_optimization: 9/10 — clean format, right length
- cta_effectiveness:    8/10 — question CTA invites comment

OVERALL: 8.9/10

GATE CHECKS: all pass

VERDICT: accept

Drei Loops. Von 2,1 auf 8,9.

Wie du es ausführst

Der einfachste Weg, den Loop manuell mit claude -p auszuführen:

# Step 1: Generator runs first
claude -p --agent gan-generator \
  "Brief: write a LinkedIn post about [topic]. Save output to output/draft.md.
   Write generator-state.md with what you produced."

# Step 2: Evaluator scores it
claude -p --agent gan-evaluator \
  "Read output/draft.md and evaluator/linkedin-criteria.md.
   Score against the rubric. Write feedback to feedback/feedback-001.md.
   Be ruthlessly strict."

# Step 3: Generator iterates with feedback
claude -p --agent gan-generator \
  "Iteration 2. Read feedback/feedback-001.md FIRST.
   Address every issue. Update output/draft.md.
   Update generator-state.md."

# Repeat until VERDICT: accept

Du kannst es auch vollständig automatisiert mit dem loop-operator-Agenten aus everything-claude-code ausführen:

# Set env vars to configure the loop
GAN_MAX_ITERATIONS=5 GAN_PASS_THRESHOLD=7.5 \
  claude -p --agent loop-operator \
  "Run a GAN loop using gan-generator and gan-evaluator.
   Brief: [your task]. Criteria file: evaluator/my-criteria.md.
   Stop when score >= 7.5 or after 5 iterations."

Die kritische Regel: Kein Gedächtnis zwischen Durchläufen

Der Evaluator liest die Rubrik bei jedem Durchlauf frisch. Das ist nicht optional.

Ein Evaluator mit Gedächtnis an frühere Scores wird sie mit der Zeit aufblähen. Er hat etwas letzte Runde mit 6 bewertet, also bewertet er es diese Runde mit 7, um "Fortschritt" zu zeigen, auch wenn die tatsächliche Verbesserung minimal war. Frische Rubrik, frische Augen, jedes Mal.

Die Loop-Konfiguration erzwingt das:

{
  "max_iterations": 3,
  "escalation": "accept-with-notes"
}

Wenn max_iterations erreicht wird ohne den Schwellenwert zu passieren, liefert das System die beste Version mit Notizen statt für immer zu blockieren. Der Output mag nicht perfekt sein, aber es ist das Beste, was der Generator in 3 Runden produzieren konnte, und du hast ein Protokoll dessen, was der Evaluator markiert hat.

Bonus: Nutze Codex als deinen Evaluator

Die mächtigste Version dieses Loops verwendet zwei verschiedene KI-Systeme. Claude als Generator. OpenAI Codex als Evaluator.

Warum das wichtig ist: Der Evaluator sucht nach Fehlern in Claudes Output. Aber Claude und Codex wurden auf verschiedenen Daten, mit verschiedenen Zielen, verschiedenen Architekturen und verschiedenen bekannten Schwächen trainiert. Claude, das Claude bewertet, übersieht die blinden Flecken, die sie teilen. Codex, das Claude bewertet, findet eine ganz andere Klasse von Problemen.

Zwei KI-Labs, die um deinen Output kämpfen.

Wenn du das codex-plugin-cc in Claude Code installiert hast:

# Install the plugin
/plugin marketplace add openai/codex-plugin-cc

# Use it in your loop
/codex:adversarial-review output/draft.md

Oder rufe Codex direkt als Evaluator-Agenten in deiner Loop-Konfiguration auf:

{
  "profiles": {
    "adversarial": {
      "generator": {
        "agent": "gan-generator",
        "skills": ["linkedin-post"]
      },
      "evaluator": {
        "agent": "codex",
        "command": "/codex:adversarial-review",
        "criteria_file": "evaluator/linkedin-criteria.md"
      }
    }
  }
}

Der Codex-Evaluator führt /codex:adversarial-review auf dem Generator-Output aus und übergibt die Kriterien-Datei als Kontext. Er hinterfragt Design-Entscheidungen, markiert Annahmen, die Claude nicht in Frage stellt, und bewertet aus einer komplett anderen Perspektive.

Cross-Modell-Bewertung ist kein Gimmick. Wenn Generator und Evaluator dieselbe Trainings-Verteilung teilen, teilen sie dieselben blinden Flecken. Ein Cross-Modell-Loop schließt diese Lücke.

Was du nach 3 Runden bekommst

Output, der konvergiert. Nicht perfekt, aber zuverlässig über dem Schwellenwert.

Das System liefert Inhalte, die eine Stunde manuelles Review gebraucht hätten, in 3 automatisierten Loops. Du hörst auf, jede Zeile zu lesen. Du hörst auf, an Hooks zu zweifeln. Du liest die Evaluator-Zusammenfassung und prüfst stichprobenartig den finalen Output.

Die Rubrik macht die Arbeit. Du definierst einmal, wie "gut" aussieht. Jedes Stück Output wird bei jedem Mal an diesem Standard gemessen, ohne Drift und ohne Ego.

Der vollständige Dateisatz für einen funktionierenden GAN Loop:

.claude/
  agents/
    gan-generator.md      ← generator agent definition
    gan-evaluator.md      ← evaluator agent definition
  subsystems/
    content/
      gan.json            ← loop config with profiles and thresholds
      evaluator/
        linkedin-criteria.md    ← rubric for LinkedIn posts
        carousel-text-criteria.md
        x-thread-criteria.md
        reddit-criteria.md
output/
  draft.md                ← generator output
  generator-state.md      ← what was built each iteration
  feedback/
    feedback-001.md       ← evaluator feedback per round
    feedback-002.md
    feedback-003.md

Kopiere die Agent-Definitionen oben, schreibe eine Rubrik-Datei für deinen Aufgabentyp, setze einen Schwellenwert und führe es aus.

Posted by @speedy_devv

GAN Loop

On this page