Adversaria

Adversaria
Critical thinking platform for Claude Code

Usage · Agents · Skills · How It Works · Traditions · Install

Adversaria is a Claude Code plugin for structured adversarial analysis. Three specialized agents argue, stress-test, and judge any idea over a shared argument graph whose verdict is decided by grounded argumentation semantics, drawing on 10 reasoning traditions, with persistent memory that accumulates insight across sessions.

The name comes from the Latin adversaria: a notebook of observations. It also evokes adversarial reasoning, the deliberate practice of challenging ideas to strengthen them.

Usage

Adversaria works through agents that Claude automatically delegates to based on what you ask. You don't need to manage the workflow yourself.

Natural language (Claude delegates automatically):

Steelman the case for rewriting our API in Go
What could go wrong with this migration plan?
Give me a verdict on this proposal
Play devil's advocate on this architecture decision

@-mention (guarantees a specific agent runs):

@advocate build the strongest case for microservices here
@adversary tear apart this launch plan
@judge what survives scrutiny in this proposal?

Slash commands (invoke a skill directly):

/adversaria:steelman the case for server-side rendering
/adversaria:crucible this database migration plan
/adversaria:verdict on the Q3 product roadmap
/adversaria:devils-advocate this entire investment thesis
/adversaria:appeal the verdict was too harsh on the migration plan

Session-wide (run an entire session as one agent):

claude --agent adversaria:advocate
claude --agent adversaria:adversary
claude --agent adversaria:judge

Agents

Three agents with distinct roles, each with persistent project memory that accumulates knowledge across sessions.

Advocate

Builds the strongest possible case for an idea with genuine conviction, then argues the complete opposite with equal force.

The advocate is not a summarizer and not a yes-man. A steelman that ignores obvious flaws is a straw man in disguise. The advocate addresses weaknesses by countering them, not hiding them.

Adversary

Finds every weakness, flaw, and failure mode. An authentic dissenter, not assigned devil's advocacy.

[!NOTE]
Psychologist Charlan Nemeth proved that assigned devil's advocacy is less effective than authentic dissent and can make people more entrenched. The adversary is an authentic dissenter who genuinely looks for flaws, not a performer going through the motions.

Judge

Renders a dispassionate verdict from the argument graph evidence. No advocacy in either direction.

The judge reads what the advocate built and what the adversary found, then determines what survives scrutiny, what does not, and what remains unresolved. Every claim in the verdict cites graph state, not opinion.

Skills

Skills are the structured workflows that agents execute internally. They are also available as standalone slash commands.

The first three are bound to an agent apiece, so Claude reaches them by delegating. devils-advocate and appeal are standalone — invoke them directly. appeal is deliberately not bound to the judge: the Roman Rota sends appeals to a different panel than the one that ruled.

[!TIP]
Skills compose through a shared argument graph that persists between runs. The steelman skill builds the graph, the crucible skill adds weaknesses to it, and the verdict skill reads the final state. Use /adversaria:devils-advocate to run all three in one pass, then /adversaria:appeal if the ruling looks wrong.

How It Works

     You ask a question
            │
            ▼
    ┌───────────────┐
    │   Claude Code  │  Delegates based on what you asked
    └───────┬───────┘
            │
    ┌───────────┼───────────┐
    ▼           ▼           ▼
┌─────────┐ ┌──────────┐ ┌─────────┐
│ Advocate│ │ Adversary│ │  Judge  │
│         │ │          │ │         │
│ steelman│ │ crucible │ │ verdict │
└────┬────┘ └─────┬────┘ └────┬────┘
     │            │           │
     └────────────┼───────────┘
                  ▼
        ┌───────────────────┐
        │  Argument Graph   │
        │                   │
        │  claims, attacks, │
        │  counters + who   │
        │  wrote each one   │
        └─────────┬─────────┘
                  │
        ┌─────────┴─────────┐
        ▼                   ▼
  grounded            live transcript
  semantics             (WebSocket)
  → verdict
        │
        ▼
     appeal
 (second panel)

1. You describe what you need. Claude reads your request and delegates to the right agent based on its description.
2. The agent invokes its skill. Each agent has a dedicated skill that defines its structured workflow: what to analyze, what to register in the graph, and what to produce.
3. Skills read and write the argument graph. The graph is the shared state layer. Claims, assumptions, evidence, weaknesses, counters, and mitigations accumulate across agent runs.
4. Results return to you. The agent summarizes its findings. The full graph state is available via analyze, verdict, or export commands.

The Argument Graph

The argument graph is a knowledge graph that decomposes ideas into typed nodes connected by typed relations.

Node types: claim assumption evidence weakness counter precedent mitigation

Relation types: supports undermines assumes depends_on contradicts if_fails mitigates

The graph persists between agent runs, scoped per project. This is by design: what the advocate builds, the adversary attacks, and the judge reads. Every record carries the agent that wrote it and a sequence number, so the graph is also a transcript of who argued what, in order.

The verdict is not a vote count

Adversaria decides what survives using grounded argumentation semantics: an attack from a node that has itself been defeated does not count.

gartner-2026 ──supports──▶ cost-reduction
vendor-lockin ──undermines──▶ cost-reduction
multi-cloud-abstraction ──undermines──▶ vendor-lockin

multi-cloud-abstraction is unattacked, so it stands. That defeats vendor-lockin. With its only attacker defeated, cost-reduction survives — having been attacked and held. Remove the counter and it fails instead.

This is what makes the contest fair. The adversary's attacks sink claims, and the advocate's counters can sink the attacks back. Nodes are labelled IN, OUT, or UNDECIDED; mutual attacks settle at UNDECIDED rather than resolving arbitrarily, and circular reasoning is reported separately.

Live transcript

Watch the agents argue in real time:

bun scripts/transcript.ts serve            # from a clone; opens your browser
bun scripts/transcript.ts serve --no-open  # print the URL instead

It serves a page on 127.0.0.1 (ephemeral port, loopback only) that streams each claim, weakness, and counter over a WebSocket as it is written, alongside the current standing of every node. Nothing starts unless you run it, and the server exits on its own after 30 idle minutes.

The Thought Chain

The thought chain tracks reasoning as numbered steps with revision and branching. Used by the /adversaria:devils-advocate orchestrator to sequence its seven-step analysis across all three phases.

Traditions

Adversaria draws from 10 intellectual traditions of structured dissent and rigorous argument.

Install

From the marketplace

/plugin marketplace add damionrashford/Adversaria
/plugin install adversaria@damionrashford-adversaria

After installing, run /reload-plugins to activate.

Local development

claude --plugin-dir /path/to/Adversaria

Requirements

• Claude Code v2.1 or later (plugin agents, async hooks)
• Bun — the engines are TypeScript run directly by Bun. No npm install; the plugin ships no dependencies.

Plugin Structure

Adversaria/
├── .claude-plugin/
│   ├── plugin.json            # Plugin manifest
│   └── marketplace.json       # Marketplace catalog
├── agents/
│   ├── advocate.md            # Steelman agent
│   ├── adversary.md           # Stress-test agent
│   └── judge.md               # Verdict agent
├── skills/
│   ├── devils-advocate/       # Full analysis orchestrator
│   │   └── SKILL.md
│   ├── steelman/              # Build the best case
│   │   └── SKILL.md
│   ├── crucible/              # Stress-test
│   │   └── SKILL.md
│   ├── verdict/               # Render judgment
│   │   └── SKILL.md
│   └── appeal/                # Second-panel review
│       └── SKILL.md
├── references/                # 10 traditions + the semantics guide, shared by all skills
├── scripts/
│   ├── argument-graph.ts      # Graph engine + grounded semantics
│   ├── thought-chain.ts       # Sequential reasoning engine
│   └── transcript.ts          # Live WebSocket transcript UI
├── hooks/
│   ├── hooks.json             # Event handlers
│   └── scripts/               # Hook scripts (TypeScript)
├── README.md
└── LICENSE

License

MIT

_{Built by Damion Rashford}