---
name: debate-gpt-brad
description: >
  Use when Mason says "Debate GPT-Brad on ___" (or "debate GPT", "have GPT and
  Claude argue about ___", "get a second opinion from GPT"). Runs a structured
  back-and-forth between Claude and OpenAI's latest GPT model that critique a
  topic, plan, or deliverable (e.g. conference abstract drafts, a refactor plan,
  next steps for a test harness) and each other, then synthesizes a verdict.
version: "1.0.1"
---

_Last updated: 2026-07-03_

# debate-gpt-brad

Mason wants two models to genuinely pressure-test something — not agree politely.
Claude and "GPT-Brad" (OpenAI's newest GPT, reached through Mason's own API key)
exchange critiques until they stop finding new substantive points, then Claude
writes up where they landed.

`gpt_brad.py` (next to this file) is the bridge to OpenAI. It finds the key
itself: `$OPENAI_API_KEY` if set, otherwise `~/.config/secrets/api-keys.env`.
Nothing here uses the Anthropic side of an API — Claude's turns are written by
you directly in the conversation.

## Setup check (do this first, once per debate)

Run one command — it both checks the key and resolves the model:
```
python3 ~/.claude/skills/debate-gpt-brad/gpt_brad.py model
```
- If it prints a model id, you're set — tell Mason which model is in play. It
  auto-picks the newest flagship `gpt-*`; they can pin one with
  `GPT_BRAD_MODEL=gpt-5.1`.
- Only if it errors with a key-not-found message does Mason need to add the
  key: point them to `~/.config/secrets/api-keys.env` (or `! export
  OPENAI_API_KEY=sk-...`). Never default to asking them to export it by hand —
  the secrets file is the normal source, and the bridge reads it automatically.

## Get the material

Pull the actual thing being debated into context before arguing about it. If the
topic references something on disk (abstract drafts, a plan doc, code), read it.
If it's ambiguous what Mason wants critiqued, ask one short question — don't guess.

## Pick the mode (ASK EVERY TIME)

Use AskUserQuestion to let Mason choose the debate mode — all six are useful at
different times, so never default:

- **Both critique, Claude synthesizes** — Claude and GPT each critique the
  material and each other as peers (no fixed sides). Best for "make this better."
- **Adversarial pro/con** — one model argues for, the other against. Ask which
  side Claude takes. Best for stress-testing a yes/no decision.
- **GPT critiques Claude's work only** — Claude drafts/defends, GPT only attacks.
  Best for "tear apart MY abstract/plan."
- **Red-Team Brad on consensus** — Claude and GPT critique as peers, then a third
  independent skeptic ("Red-Team Brad") attacks everything, reserving its sharpest
  fire for the points the two AGREE on and the synthesis they're converging toward.
  Best for catching correlated error / shared blind spots when both models nod along.
- **Two cross-examiners (3rd + 4th)** — Claude and GPT critique, then Cross-Examiner
  X dismantles ClaudeBrad's position and Cross-Examiner Y dismantles GPT-Brad's.
  Four voices, ~2x cost. Best for high-stakes deliverables you want hammered hard.
- **Rigorous scientists** — both Brads are PhD-level domain experts who back every
  claim with evidence and the scientific literature, and are as intellectually
  honest as a person can be. Best for "is this claim actually true?" / evidence
  questions. See the scientist rules below — this mode lives or dies on citation
  honesty.

## Run the debate

Loop, capped at **5 rounds** (one round = Claude turn + GPT turn). Stop early when
**two consecutive rounds surface no new substantive point** (convergence) — say so
explicitly when you stop.

Each turn:

1. **Claude's turn** — write it directly in the conversation. Be specific and
   critical; cite concrete lines/claims from the material. Don't soften to be
   agreeable — the value is in disagreement.
2. **GPT's turn** — call the bridge. Build the request as a JSON file in the
   scratchpad and pipe it in. Pass the *whole running transcript* so GPT has full
   context: GPT's own past turns are `assistant`; everything else (the material,
   the task framing, Claude's turns) is `user`.

   Write the request to your session's scratchpad directory (listed in your
   system prompt — session-specific, so never copy a literal path from an old
   transcript). With `$SCRATCHPAD` standing in for that directory:

   ```bash
   cat > "$SCRATCHPAD/gpt_req.json" <<'JSON'
   {
     "system": "You are GPT-Brad, a sharp, candid critic debating Claude. <MODE INSTRUCTIONS>. Be concrete and cite specifics. Concede points that are genuinely right; press hard on what is weak. Do not be sycophantic.",
     "messages": [
       {"role": "user", "content": "<material + task framing + Claude's latest turn and the prior transcript>"}
     ]
   }
   JSON
   python3 ~/.claude/skills/debate-gpt-brad/gpt_brad.py ask < "$SCRATCHPAD/gpt_req.json"
   ```

   Use a single-quoted heredoc only if the content has no problematic characters;
   otherwise write the JSON with the Write tool to avoid quoting/escaping bugs.
   Set `<MODE INSTRUCTIONS>` from the chosen mode (e.g. for pro/con: "You argue
   AGAINST the proposal").

3. Show each turn to Mason as it happens, labeled **Claude** and **GPT-Brad**, so
   they watch the exchange unfold.

### Extra adversary voices (modes 4 and 5 only)

The adversaries are **independent GPT calls with a clean skeptic persona** — no
memory of being GPT-Brad, no loyalty to either debater. That independence is the
point: Claude must not grade Claude, so route adversary turns through the bridge,
not through your own voice.

Run the adversary pass **at the end of each round**, after Claude and GPT have
spoken. Their objections feed the next round, and convergence now also requires
the adversaries to stop finding new substantive holes.

- **Red-Team Brad (mode 4)** — one extra call per round. System prompt:
  > "You are Red-Team Brad, an independent skeptic with no loyalty to either
  > debater. Attack every claim below. Reserve your sharpest fire for the points
  > the two debaters AGREE on and the synthesis they are converging toward — treat
  > their agreement as correlated error or a shared blind spot until proven
  > otherwise. Be concrete; cite the specific claim you're hitting."

  Pass the full transcript so far as the `messages`.

- **Cross-examiners (mode 5)** — two extra calls per round, each scoped to one side:
  - **Cross-Examiner X** attacks ClaudeBrad. System prompt: "You are Cross-Examiner
    X. Your only job is to dismantle the position attributed to ClaudeBrad below —
    every weakness, unstated assumption, and failure mode. Ignore GPT-Brad."
  - **Cross-Examiner Y** attacks GPT-Brad, symmetric.

  Give each one the transcript but make explicit whose position it is assigned to
  destroy. Label their turns **Cross-Examiner X** / **Cross-Examiner Y**.

After each adversary speaks, Claude and GPT should answer the strongest hits in
the next round (concede or rebut) rather than ignoring them.

### Rigorous-scientist rules (mode 6 only)

Both Brads argue as PhD-level domain experts. The persona is *intellectual
honesty*, not credential cosplay — so the rules below are the point of the mode,
not flavor text. Apply them to Claude's turns AND to GPT's (put them in GPT's
system prompt):

- **No fabricated evidence.** Cite only real, verifiable sources. If you can't
  name a specific source you're confident exists, say "I believe the literature
  shows X, but I can't cite a specific paper from memory" — never invent a title,
  author, journal, year, or DOI. A made-up citation fails the mode outright.
- **Calibrate every claim.** Mark each as well-established / contested / your own
  inference / speculative, and state your confidence. Distinguish what the
  evidence shows from what you believe.
- **Steelman, then engage.** Represent the other Brad's position at its strongest
  before critiquing. Attack reasoning and evidence, not phrasing.
- **Concede readily.** When the other side is right, say so explicitly. Changing
  your mind on evidence is the win condition, not a loss.
- **Surface the crux.** Identify what evidence *would* change your view, and where
  the disagreement is empirical (resolvable by data) vs definitional.

Because honesty here means *grounded* claims, Claude should verify load-bearing
citations with WebSearch/WebFetch rather than trusting memory, and should openly
flag any of GPT's citations it could not verify. The synthesis must separate
**what the evidence supports** from **what remains uncertain**, and list the
specific studies/data that would settle the open questions.

## Synthesize

After the loop, Claude writes a final synthesis:

- **Points of agreement** — what both sides converged on.
- **Unresolved disagreements** — where they still differ, and the strongest case
  for each side.
- **Recommendation** — concrete next step / the version to go with / the edit to
  make. Take a position; don't punt.

(For "GPT critiques Claude's work only" mode, frame the synthesis as Claude's
revised draft/plan incorporating the valid hits.)

(For modes 4 and 5, add a **Surviving objections** section: which adversary hits
were never adequately answered. Those are the real risks — call them out plainly
rather than letting the synthesis paper over them.)

## Save the transcript

Write the full debate + synthesis to a dated markdown file and tell Mason the path:

```
~/gpt-brad-debates/YYYY-MM-DD-<short-slug>.md
```

Create the folder if needed. Header the file with the topic, date, mode, and the
GPT model used. Match Mason's house style — date-stamp it, don't make it read as
machine-generated.

## Common mistakes

- **Being too agreeable.** Both sides hedging into consensus wastes the exercise.
  Push for real disagreement; that's where the value is.
- **Dropping context.** GPT only knows what you send. Always include the material
  and prior turns in the messages, or its critiques drift.
- **Skipping the mode menu.** Always ask — the six modes serve different needs.
- **Running to 5 rounds on autopilot.** Stop at convergence and name it.
