┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│  ┌───────────┐    output    ┌───────────┐                      │
│  │           │─────────────▶│           │                      │
│  │ GENERATOR │              │ EVALUATOR │                      │
│  │  (Agent)  │◀─────────────│  (Agent)  │                      │
│  │           │   feedback   │           │                      │
│  └───────────┘              └───────────┘                      │
│       │                           │                            │
│       │ (if approved)             │                            │
│       ▼                           │                            │
│  ┌─────────┐                      │                            │
│  │ FINAL   │◀─────────────────────┘                            │
│  │ OUTPUT  │     (pass/fail + score)                           │
│  └─────────┘                                                   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

## Generator Task

Create: [description of output]
Requirements: [specific requirements]
Format: [expected format]

## Output Format

Provide your output with clear sections:
- Main content
- Self-assessment of quality
- Areas of uncertainty

## Evaluator Task

Review the following output:
[generator output]

Evaluation Criteria:
1. Correctness: Does it meet the requirements?
2. Completeness: Are all aspects covered?
3. Clarity: Is it understandable?
4. Quality: Does it follow best practices?

## Output Format

Score: [0-100]
Pass: [true/false] (threshold: 80)

Strengths:
- [what works well]

Issues:
- [Issue 1]: [specific problem]
  Fix: [actionable improvement]
- [Issue 2]: [specific problem]
  Fix: [actionable improvement]

Verdict: [PASS / NEEDS_REVISION]

# Conceptual flow
max_iterations = 3
iteration = 0
passed = False

while iteration < max_iterations and not passed:
    # Generate
    output = generator.create(requirements, feedback)

    # Evaluate
    evaluation = evaluator.review(output, criteria)

    if evaluation.score >= threshold:
        passed = True
    else:
        feedback = evaluation.issues
        iteration += 1

return output, evaluation

name: generator
model: sonnet  # or inherit for complex tasks
tools: Read, Write, Edit, Glob, Grep
permissionMode: acceptEdits

name: evaluator
model: sonnet  # Use same or stronger model
tools: Read, Glob, Grep  # Read-only evaluation
permissionMode: plan
disallowedTools: Write, Edit, Bash

## Iteration 1

### Generator Output
```typescript
/**
 * Creates a user
 * @param data - user data
 */
function createUser(data: UserData): User { ... }

/**
 * Creates a new user account with the provided data.
 *
 * @param data - The user creation data
 * @param data.email - Valid email address (must be unique)
 * @param data.password - Password (min 8 chars, hashed before storage)
 * @param data.name - Display name (optional)
 *
 * @returns The created User object with generated ID
 *
 * @throws {DuplicateEmailError} If email already exists
 * @throws {ValidationError} If data fails validation
 *
 * @example
 * const user = await createUser({
 *   email: 'john@example.com',
 *   password: 'securePass123'
 * });
 */
function createUser(data: UserData): Promise<User> { ... }

### Example 2: Algorithm Optimization

```markdown
## Iteration 1

### Generator Output
function findDuplicates(arr) {
  const duplicates = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
        duplicates.push(arr[i]);
      }
    }
  }
  return duplicates;
}

### Evaluator Feedback
Score: 55
Issues:
- Performance: O(n²) time complexity, O(n) for includes
- Correctness: Works but inefficient
Fix: Use Set or Map for O(n) solution

### Iteration 2

### Generator Output (Improved)
function findDuplicates(arr) {
  const seen = new Set();
  const duplicates = new Set();

  for (const item of arr) {
    if (seen.has(item)) {
      duplicates.add(item);
    } else {
      seen.add(item);
    }
  }

  return [...duplicates];
}

### Evaluator Feedback
Score: 95
Verdict: PASS
Strengths:
- O(n) time complexity
- O(n) space complexity (optimal for this problem)
- Clean, readable implementation

1. code-architect generates initial design
2. Evaluator checks against:
   - Codebase patterns
   - Scalability requirements
   - Security considerations
3. Iterate until design scores >= 85

1. Implementation complete
2. qa-engineer evaluates test coverage
3. If coverage < 80%, iterate:
   - Identify gaps
   - Add tests
   - Re-evaluate

pass@k = 1 - (1 - p)^k  where p = per-trial success rate

Example with p = 0.7:
- pass@1 = 0.70  (70% chance of success on single try)
- pass@3 = 0.97  (97% chance at least one succeeds)
- pass^3 = 0.34  (34% chance all three succeed)

1. Start with code-based graders for objective criteria
   - JSON schema validation
   - Required field presence
   - Format compliance

2. Add model-based graders for subjective criteria
   - Code quality assessment
   - Documentation clarity
   - Design appropriateness

3. Reserve human graders for:
   - Calibrating model-based graders
   - Edge case evaluation
   - Final sign-off on critical outputs

Generator Output
      │
      ├──▶ Correctness Evaluator
      │
      ├──▶ Style Evaluator
      │
      ├──▶ Performance Evaluator
      │
      └──▶ Security Evaluator

Combined Score = weighted average
Feedback = aggregated from all evaluators