adversarial-spec — Summary

adversarial-spec is a Claude Code plugin that refines product specifications through multi-model adversarial debate: Claude drafts an initial spec, then multiple external LLMs (GPT, Gemini, Grok, Mistral, etc.) critique it in parallel, Claude synthesizes all critiques plus its own, revises the spec, and the loop continues until all models AND Claude reach consensus. This makes it the only framework in this batch (and the corpus) that uses a consensus mechanism across multiple LLMs to produce a specification, rather than using specs to guide code generation. It ships one Claude Code slash-command (/adversarial-spec), one skill (SKILL.md), and a debate.py Python engine that uses litellm to call any provider. The framework supports 11 LLM providers (OpenAI, Anthropic, Google, xAI, Mistral, Groq, OpenRouter, Codex CLI, Gemini CLI, Deepseek, Zhipu) and AWS Bedrock enterprise routing. With 546 stars and 47 forks, it is the most-starred framework in this batch. Closest seed is superpowers (both are Claude Code plugins), but adversarial-spec replaces sequential skill-based workflows with a cross-model debate loop targeting spec quality rather than code quality.

adversarial-spec — Origin & Philosophy

Origin

Created by zscole (single maintainer). Last commit January 2026. 546 stars, 47 forks, 6 contributors. Status: active.

Key Insight (verbatim from README)

"A single LLM reviewing a spec will miss things. Multiple LLMs debating a spec will catch gaps, challenge assumptions, and surface edge cases that any one model would overlook. The result is a document that has survived rigorous adversarial review."

"Claude is an active participant, not just an orchestrator. Claude provides independent critiques, challenges opponent models, and contributes substantive improvements alongside external models."

Core Philosophy

Apply adversarial review (red-teaming) to specification documents rather than to code. The specification quality problem is treated as a consensus problem across diverse LLM perspectives: if GPT, Gemini, Grok, and Claude all independently agree the spec is complete and accurate, it has survived multi-model scrutiny.

Workflow (verbatim)

You describe product --> Claude drafts spec --> Multiple LLMs critique in parallel
        |                                              |
        |                                              v
        |                              Claude synthesizes + adds own critique
        |                                              |
        |                                              v
        |                              Revise and repeat until ALL agree
        |                                              |
        +--------------------------------------------->|
                                                       v
                                            User review period
                                                       v
                                            Final document output

Positioning

adversarial-spec sits at the intersection of:

1. Specification quality assurance (like Kiro's steering/spec format, but automated)
2. Multi-model consensus (unique in this corpus)
3. Claude Code plugin pattern (like superpowers, but with external LLM calls)

adversarial-spec — Architecture

Distribution

Claude Code plugin (installed via claude plugin marketplace add zscole/adversarial-spec).

Install

claude plugin marketplace add zscole/adversarial-spec
claude plugin install adversarial-spec
export OPENAI_API_KEY="sk-..."   # or OPENROUTER_API_KEY, GEMINI_API_KEY, etc.
/adversarial-spec "Build a rate limiter service with Redis backend"

Required Runtime

• Python 3.10+
• litellm package: pip install litellm
• API key for at least one LLM provider

Directory Structure

.claude-plugin/
├── marketplace.json   # plugin marketplace config
└── plugin.json        # plugin manifest
skills/
└── adversarial-spec/
    ├── SKILL.md        # skill definition + provider docs
    └── scripts/
        └── debate.py  # Python debate engine (litellm-based)

Target AI Tools

Primary: Claude Code. The debate.py engine also supports:

• Codex CLI (via codex/ prefix)
• Gemini CLI (via gemini-cli/ prefix) Both CLIs used as client-side model providers (no API key required, uses subscription auth).

Supported LLM Providers

adversarial-spec — Components

Commands / Skills (1 each)

Python Engine (skills/adversarial-spec/scripts/debate.py)

The debate.py file is the core engine with subcommands:

Config stored at: ~/.claude/adversarial-spec/config.json

Debate Loop (implemented in debate.py)

1. Claude drafts initial spec (PRD or tech spec)
2. Optional: interview mode to capture requirements first
3. debate.py critique — sends spec to opponent models in parallel, collects critiques
4. Claude synthesizes all critiques + adds its own critique
5. Claude revises spec based on synthesis
6. Loop to step 3 until ALL models AND Claude agree (consensus check)
7. User review period: request changes or run additional cycles
8. Output final converged document

Reasoning Effort Control (Codex CLI)

python3 debate.py critique --models codex/gpt-5.2-codex --codex-reasoning high
# Levels: low, medium, high, xhigh (default: xhigh)

No Hooks / No MCP

Zero Claude Code hooks, zero MCP servers.

adversarial-spec — Uniqueness & Positioning

differs_from_seeds

Closest seed is superpowers (both are Claude Code plugins), but adversarial-spec replaces sequential skill-based behavioral workflows with a cross-model debate consensus loop. Where superpowers' verification-before-completion skill has Claude review its own work, adversarial-spec has 3–5 independent LLMs critique it. Against spec-kit (Python CLI generating prompt scaffolds), adversarial-spec is not a CLI at all — it is a dynamic debate engine that calls external APIs. Among all seeds, no framework implements a consensus mechanism across multiple LLMs; adversarial-spec is the first in this corpus to treat specification quality as a multi-model consensus problem.

Unique Positioning

The only framework in the entire corpus that:

1. Uses multiple external LLMs to review a specification before it is used to guide development
2. Implements an "all-agree" consensus termination condition across LLM critics
3. Positions Claude as a participant-critic, not just an orchestrator
4. Supports 11+ LLM providers with a litellm backend
5. Includes AWS Bedrock enterprise routing mode

Observable Failure Modes

1. Cost escalation: each debate round calls multiple external models; cycles can multiply cost quickly.
2. Consensus gridlock: models may never fully agree, especially on subjective product decisions — no max-cycles limit visible in docs.
3. Claude auth conflict: unique failure mode where claude.ai token + ANTHROPIC_API_KEY conflict when Claude tries to call Anthropic API as an external opponent.
4. No spec persistence: final spec is not formally stored with metadata; output is raw markdown in session.
5. Python dependency: requires Python 3.10+ and litellm separately from Claude Code; increases install complexity.
6. Single maintainer: 6 contributors but primarily zscole; dependency on one person for updates.

Explicit Antipatterns (inferred from SKILL.md)

• Installing the llm package (Simon Willison's tool) — explicitly warned against: "Do NOT install the llm package"
• Using ANTHROPIC_API_KEY when logged into claude.ai (causes auth conflict)