The Duel (Face Off) skill
A Claude Code skill: an OpenAI model critiques an answer, Claude defends it for up to three rounds and returns a claim ledger
- 75 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The prepared packet with the answer and context goes to the third-party OpenAI API, so check it for secrets first
- Each critic round is billed at OpenAI API rates, and a normal run makes up to three calls
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/the-duel-face-offDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The prepared packet with the answer and context goes to the third-party OpenAI API, so check it for secrets first
- Each critic round is billed at OpenAI API rates, and a normal run makes up to three calls
This is third-party code. Review the repository files before installing.
What it does
The skill makes Claude Code defend its own answer in front of a second model. The phrase "Duel this with ChatGPT" or the `/duel` command sends the answer to an OpenAI model for critique through the Responses API (default `gpt-6-astra`, changed with the `DUEL_OPENAI_MODEL` variable or the `--model` flag). The defender stays Claude Code: it keeps what survived the critique, fixes weak points and writes the final synthesis itself. The duel runs up to three rounds, the `--quick` flag leaves one and `--rounds` accepts 1, 2 or 3. Rounds can end early if the critique adds nothing substantive. At the end you get the revised answer and a claim ledger with stable IDs: retained, revised, dropped or unresolved. Concessions stay visible and disputed points stay disputed. The helper `skills/duel/scripts/duel.py` is written on the Python standard library and sends only the prepared packet with critic instructions. The repository and conversation are not uploaded wholesale, requests use `store: false` and the input limit is 128 KiB. Without an API key there is a manual mode: an external model critiques the packet and you paste its real response back. The skill must label that mode and cannot invent an external model taking part.
Who it is for. People who get analysis, estimates and recommendations from Claude Code and want another model objections tested before they decide.
Good fit when
- Before raising a price or launching a service you want an answer that survived a second model critique
- A technical plan or review needs its weak claims and counterexamples found
- You want a ledger of which claims held up and which had to be revised
- There is no OpenAI API key but an external model is available by hand, and you want the manual duel mode
Not a fit when
- You need independent fact verification: the duel has no neutral judge and Claude writes the result
- The answer contains secrets or sensitive material: the packet goes to the third-party OpenAI API
- You want critique through a ChatGPT subscription: the critic works only through the paid OpenAI API
Example request
Duel this with ChatGPT: my answer about raising the coaching price from $500 to $700, two rounds.Limitations
Claude Code and Python 3.9 or newer are required. The critic needs `OPENAI_API_KEY` in the environment that launches Claude Code, and the key must not be pasted into chat. No Anthropic key is needed: the defender is the current Claude Code session. A normal run makes up to three critic calls, `--quick` one, billed at OpenAI API rates.
The final answer carries no guarantee of correctness: the debate surfaces weak points and does not replace checking every fact. The request is not stored application-side because of `store: false`, but that does not promise zero retention. The critic gets no tools, and run records live in the `.duel/` directory.
How to disable. Delete the `~/.claude/skills/duel` folder or the project `.claude/skills/duel`. For the plugin run `/plugin uninstall duel-skill@duel-skill`. Clear the `.duel/` directory with run records by hand and remove `OPENAI_API_KEY` from the environment if it is no longer needed.
FAQ
How do I install the Duel skill in Claude Code?
Run `git clone https://github.com/Jakeschincariol/duel-skill.git`, then `mkdir -p ~/.claude/skills` and `cp -R duel-skill/skills/duel ~/.claude/skills/duel`. A plugin exists too: `/plugin marketplace add Jakeschincariol/duel-skill` and `/plugin install duel-skill@duel-skill`.
Do I need a ChatGPT subscription?
No. The critic runs through the paid OpenAI API with the `OPENAI_API_KEY` key. "ChatGPT" in the name is just a friendly label, and the subscription and app are not used.
How many rounds does a duel have?
Up to three by default. The `--quick` flag leaves one round, `--rounds` accepts 1, 2 or 3, and a run can end early if the critique adds nothing substantive.
What is sent to OpenAI?
The prepared packet with the task, the answer, needed context and critic instructions, sent to `https://api.openai.com/v1/responses`. The repository and conversation are not sent wholesale, and the input limit is 128 KiB.
How do I work without an API key?
Use manual mode, `/duel --manual --quick`: you show the prepared packet to an external model yourself and paste its real response back into Claude.
Discussion
No questions or reviews yet.
Related
SkillsA Claude Code skill: when you dislike an answer, it runs up to 100 sub-agents through attack-and-defend rounds and returns the one solution left standing
A Claude Code plugin that asks several AI models the same question and shows their answers side by side with a synthesis of agreement and divergence
A Claude Code skill that hands implementation-heavy work to Codex CLI while Claude keeps planning, review and acceptance.
A Claude Code plugin that hands coding tasks to Codex agents, monitors them and verifies the results independently
A skill that turns a goal into a ready prompt: the agent works in builder and critic loops until its output wins a blind comparison with a reference
claude-mods adds 112 skills, 3 agents and 3 commands to Claude Code: stacks, agent operation, defense, session continuity.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| The Duel (Face Off) (this card) | no | 75 | |
| LLM Council | no | 3,015 | gathers opinions of several advisor models, while this one sets one critic against a Claude defense and keeps a claim ledger |
| Claude-Codex Review Skill | no | 5 | reviews code through Codex, while this one critiques any Claude answer with an OpenAI model and returns a claim ledger |
README in short
The description explains that "ChatGPT" in the name means a critic through the OpenAI API while Claude Code stays the defender and author of the result. It then covers three install paths, key setup, round steps, the claim ledger, data-sending rules and offline checks of the helper.
README badge
Original SKILL.md
---
name: duel
description: Have an OpenAI model challenge Claude's answer, then defend or revise it through a short evidence-led debate. Use for "duel this with ChatGPT", "face off this answer", or an explicit request for a second model to critique an answer.
---
# Duel — Face Off
Turn a questionable answer into a stronger one by exchanging actual critiques with
an OpenAI model. You are the defender and final editor in the current Claude Code
session. The bundled helper calls the critic through the OpenAI API. Never write
both sides yourself and describe it as two models debating.
## Start with the user's question
- `/duel` uses the last substantive request and the answer the user wants challenged.
- `/duel <task>` drafts an initial answer to that task, then debates it.
- `/duel --quick` allows one critique/revision exchange.
- `/duel --rounds N` allows 1–3 exchanges; default maximum is 3.
- `/duel --model MODEL` selects the critic. Otherwise use `DUEL_OPENAI_MODEL`, then
the helper's default. `/duel --manual` uses critiques the user supplies from a
separate model instead of the API.
Interpret flags as data. Never interpolate raw user arguments into a shell command.
Ask a short clarifying question only if the target request or answer is ambiguous.
Do not broaden the original task. A debate about an action does not authorize
performing that action.
An explicit request to use Duel authorizes its ordinary bounded critique calls.
If you merely suggest Duel during another task, get agreement before sending that
task to another provider. Keep normal tool permissions in force. Briefly tell the
user which model will receive the prepared question, answer, and relevant context,
and the maximum number of calls. OpenAI API usage is billed separately.
## Prepare the exchange
1. Run `python3 "${CLAUDE_SKILL_DIR}/scripts/duel.py" check` (add `--model` when the
user selected one). It checks configuration
without making a network request or printing the API key. A successful check
does not prove the key is valid or the model is accessible.
2. If configuration is missing, explain how to set `OPENAI_API_KEY` in the terminal
environment that launches Claude Code, or offer manual mode. Never ask the user
to paste a key into chat, read credential stores, or quietly substitute a
simulated critic. A different model requires the user's choice if the configured
model fails.
3. Create a unique run folder under `.duel/` in the working project, with private
permissions where supported. Store only the selected task, answer, necessary
context, and debate artifacts there. These can be sensitive: do not commit them
or change the project's ignore rules without authorization. If the project
cannot be written, use a temporary run folder and report its location.
4. Identify the material claims in the initial answer. Assign stable IDs such as
C1, C2, C3. Capture constraints and user-supplied facts separately from guesses.
Include only relevant content authorized for this task, with credentials removed.
Do not collect the whole conversation or scan unrelated project files.
Read [references/protocol.md](references/protocol.md) for the exact packet and file
formats before the first exchange. Write JSON with a file-writing tool or a JSON
serializer. Use distinct filenames for each round and do not overwrite prior runs.
## Run the debate