Skip to content
Back to search

arena-skill

When Claude keeps giving you bad answers, make 100 versions of it fight to the death. Same task, 100 different strategies, a bracket, one answer left. Free Claude Code skill.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/jakeschincariol--arena-skill/badge.svg)](/listings/jakeschincariol--arena-skill)

HTML

<a href="/listings/jakeschincariol--arena-skill"><img src="/api/listings/jakeschincariol--arena-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Paste this into Claude:

https://github.com/Jakeschincariol/arena-skill

Install this skill, then confirm /arena works.

Or copy the folder yourself, in Claude Code:

git clone https://github.com/Jakeschincariol/arena-skill.git
cp -r arena-skill/skills/arena ~/.claude/skills/

Or as a plugin:

/plugin marketplace add Jakeschincariol/arena-skill
/plugin install arena-skill@arena-skill

Claude Code namespaces plugin skills, so installed as a plugin it shows up as `/arena-skill:arena`. Copy the folder instead if you want plain `/arena`. Project-local instead of global: copy the same folder into your repo's `.claude/skills/`.

It needs Claude Code, because it spawns sub-agents with the Agent tool, and Python 3.8 or newer. Nothing to pip install.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 18 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "arena-skill",
  4. "description": "The Arena skill for Claude Code",
  5. "owner": {
  6. "name": "Jake Schincariol",
  7. "url": "https://opusjake.ai"
  8. },
  9. "plugins": [
  10. {
  11. "name": "arena-skill",
  12. "description": "Spins up 100 sub-agents on the exact same task, each with a different strategy card, and runs them through an attack, defend and judge bracket until one answer survives.",
  13. "source": "./",
  14. "category": "productivity",
  15. "homepage": "https://github.com/Jakeschincariol/arena-skill"
  16. }
  17. ]
  18. }
README.md · README · 214 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # The Arena skill
  2. When Claude keeps giving you bad answers, make 100 versions of it fight to the death. One Claude
  3. Code skill. Free, MIT, no signup, no API key, nothing to connect.
  4. You use it when you are not happy with what Claude gave you. Instead of asking again and again,
  5. `/arena` spins up 100 sub-agents and gives every one of them the exact same task, word for word.
  6. Each one gets a different strategy card: a way of reasoning, a workflow and a strategy, so each one
  7. attacks the task differently. Then they pair off. Each attacks the other's solution, each defends
  8. and revises its own, and a judge scores the match on a written rubric. The loser is out. 100
  9. becomes 50, then 25, 13, 7, 4, 2, 1.
  10. What comes back is the one solution that survived, the attacks it beat on the way, and how many
  11. rounds it took.
  12. **It never touches your files.** Every sub-agent writes inside `.arena/`. The winning answer comes
  13. back to you, and using it is your call.
  14. ## Install
  15. Paste this into Claude:
  16. ```
  17. https://github.com/Jakeschincariol/arena-skill
  18. Install this skill, then confirm /arena works.
  19. ```
  20. Or copy the folder yourself, in Claude Code:
  21. ```bash
  22. git clone https://github.com/Jakeschincariol/arena-skill.git
  23. cp -r arena-skill/skills/arena ~/.claude/skills/
  24. ```
  25. Or as a plugin:
  26. ```
  27. /plugin marketplace add Jakeschincariol/arena-skill
  28. /plugin install arena-skill@arena-skill
  29. ```
  30. Claude Code namespaces plugin skills, so installed as a plugin it shows up as `/arena-skill:arena`.
  31. Copy the folder instead if you want plain `/arena`. Project-local instead of global: copy the same
  32. folder into your repo's `.claude/skills/`.
  33. It needs Claude Code, because it spawns sub-agents with the Agent tool, and Python 3.8 or newer.
  34. Nothing to pip install.
  35. ## Use it
  36. ```
  37. /arena
  38. /arena --quick write the headline for our pricing page
  39. /arena --agents 32 fix the flaky test in tests/test_api.py
  40. /arena --seed 7 plan my launch week, I have 6 hours a day
  41. ```
  42. On its own, `/arena` takes your last request as the task and the answer you did not like as the one
  43. to beat. Claude can also reach for it without the slash, when you say something like "that's a bad
  44. answer, make them compete". When it starts itself like that, it asks before it spends anything.
  45. | flag | what it does |
  46. | --- | --- |
  47. | `--agents N` | N competitors. Default 100. |
  48. | `--quick` | 16 competitors. The everyday setting. |
  49. | `--seed S` | Same seed, same cards and same bracket. Default random, and recorded. |
  50. | `--wave W` | Sub-agents per wave. Default 10. Only raise it if you raised Claude Code's limit. |
  51. ## How it works
  52. 1. **Spawn.** N sub-agents, one Agent call each. Every one gets the same task text, byte for byte
  53. (a test checks it), plus one strategy card. There are 15 reasoning modes (first principles,
  54. inversion, analogy, adversarial, constraint first, worked example, Socratic, contrarian, systems
  55. thinking and more), 12 workflows (draft, critique, rewrite; outline first; test first; research,
  56. then synthesise; three drafts, pick one...) and 12 strategies (simplest thing that works, maximal
  57. rigour, user empathy first, edge cases first, speed...). That is 2,160 different cards. The
  58. dealer gives each agent its own, with no repeats.
  59. 2. **Attack.** Solutions are paired, and the pairing avoids putting two agents with the same
  60. reasoning mode against each other. Each side attacks the other's solution through its own card:
  61. what is wrong, what requirement it missed, the exact input that breaks it. Up to 7 attacks,
  62. labelled FATAL, MAJOR or MINOR.
  63. 3. **Defend.** Each side answers every attack it took, conceding or rebutting with evidence, then
  64. rewrites its solution to fix everything it conceded.
  65. 4. **Judge.** A separate judge sub-agent reads both revised solutions, checks every attack itself,
  66. and scores both on [the rubric](skills/arena/rubric.md): correctness 30, completeness against the
  67. task 25, robustness to the attacks raised 20, specificity 15, clarity 10. The judge never sees
  68. the cards. `bracket.py` does the arithmetic: the higher total goes through, and a solution with a
  69. verified fatal flaw cannot beat one without. The loser is out.
  70. 5. **Repeat.** The survivors carry their revised solutions into the next round. An odd number means
  71. one bye, never to the same agent twice while anyone else is waiting for one.
  72. 6. **Result.** One solution left. You get it, the attacks it survived, its card and the round count.
  73. If you started from an answer you rejected, a last judge compares the winner with it blind and
  74. the skill tells you the score, even when the old answer wins.
  75. The 100-agent bracket, from `python3 skills/arena/bracket.py plan`:
  76. ```
  77. round alive matches bye sub-agent calls waves
  78. spawn 100 - - 100 10
  79. 1 100 50 - 250 25
  80. 2 50 25 - 125 13
  81. 3 25 12 yes 60 8
  82. 4 13 6 yes 30 5
  83. 5 7 3 yes 15 3
  84. 6 4 2 - 10 3
  85. 7 2 1 - 5 3
  86. total 595 70
  87. alive per round: 100 -> 50 -> 25 -> 13 -> 7 -> 4 -> 2 -> 1
  88. ```
  89. The whole tournament lives in one JSON file, managed by `bracket.py`. The main Claude session
  90. only runs the loop and never reads the hundreds of solution files: every sub-agent writes its work
  91. to disk and replies with one line, so the main context holds receipts and bookkeeping, not the
  92. work. If the conversation gets compacted halfway through, `bracket.py next` picks it up from the
  93. file.
  94. ## What it costs
  95. The skill is free. The tokens are yours, and 100 agents is a lot of them.
  96. | agents | rounds | sub-agent calls | waves of 10 |
  97. | --- | --- | --- | --- |
  98. | 100, the default | 7 | 595 | 70 |
  99. | 64 | 6 | 379 | 49 |
  100. | 32 | 5 | 187 | 28 |
  101. | 16, `--quick` | 4 | 91 | 16 |
  102. | 8 | 3 | 43 | 10 |
  103. Add one call when there is a rejected answer to beat. Every call reads the task and one or two
  104. solutions, so the bill grows with the size of the task. Use `--quick` or `--agents 16` for
  105. everyday things and save the full 100 for the answer that matters. The skill prints these numbers
  106. before it starts, and `python3 skills/arena/bracket.py plan --agents N` prints them any time.
  107. ## The tool
  108. `bracket.py` is standard-library Python. It is the reason the orchestrator never loses track.
  109. ```bash
  110. python3 bracket.py plan --agents 100 # rounds, calls, waves. Writes nothing
  111. python3 bracket.py init --agents 100 --seed 7 --task-file task.md [--baseline-file old.md]
  112. python3 bracket.py next # what to do now, with the exact command
  113. python3 bracket.py prompts attack # write every sub-agent brief, list the jobs in waves
  114. python3 bracket.py pairings # this round's matches, including the bye
  115. python3 bracket.py collect # record the judges' verdicts
  116. python3 bracket.py record r3-m07 a042 --reason "..." # or record one by hand
  117. python3 bracket.py advance # eliminate the losers, pair the survivors
  118. python3 bracket.py status # alive and eliminated, per round
  119. python3 bracket.py winner # the survivor, the attacks it survived, the rounds
  120. ```
  121. The tests run a full 100-agent tournament through that command line with random winners and check
  122. it ends with exactly one survivor, plus 16, 7 and 1 agents, the dealer's guarantees, and every
  123. phase from spawn to the final check with stand-in sub-agents:
  124. ```bash
  125. python3 -m unittest discover -s tests -v
  126. ```
  127. ## The fine print
  128. **"100 versions of Claude" means 100 sub-agents of the model you are running.** Not 100 different
  129. models. What makes them different is the card. The dealer guarantees that no two agents get the
  130. same card, that every reasoning mode, workflow and strategy is dealt as evenly as possible, and that
  131. up to 144 agents, no two agents even share two of their three parts.
  132. **A competitor is its card plus its solution file.** Sub-agents do not remember anything between
  133. calls, so when competitor a017 attacks in round 3, that is a fresh sub-agent handed a017's card and
  134. a017's latest solution. 100 competitors, 595 calls.
  135. **"The best answer" means the one that survived every match.** The judges are Claude too, scoring
  136. against a written rubric that is in this repo for you to read and change. What you get is the
  137. strongest answer this tournament found, not a proof that it is right. That is why it shows you the
  138. attacks it survived, and why it tells you straight when the answer you rejected scored higher.
  139. **100 agents do not all run at the same moment.** Claude Code runs at most 10 tool calls at once by
  140. default (the `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` setting), so the arena runs in waves of 10. The
  141. spawn is 10 waves, the whole 100-agent run is 70, and it takes a while. If you raise that limit,
  142. pass `--wave` to match.
  143. **Expect permission prompts unless you allow edits.** Every sub-agent writes a file into `.arena/`,
  144. and in the default permission mode that is one approval per file. Run it in accept-edits mode
  145. (Shift+Tab).
  146. **Sub-agents cannot see your chat.** The skill writes a standalone task file, and that file is all
  147. 100 agents ever know. If a requirement never made it into the file, all 100 miss it. It is at
  148. `.arena/<run>/task.md` if you want to check.
  149. **It never edits your project.** Code changes come back as a diff or as full files inside the
  150. winning answer. Applying them is your call, and the skill asks.
  151. **The same seed gives the same cards and the same bracket.** Not the same answers. The model is not
  152. deterministic.
  153. **It does not fix a bad task.** Vague task in, 100 flavours of vague out.
  154. ## Files
  155. ```
  156. skills/arena/SKILL.md the orchestration steps and the exact brief every sub-agent gets
  157. skills/arena/bracket.py the tournament state machine, standard library only
  158. skills/arena/strategies.json 15 reasoning modes, 12 workflows, 12 strategies. Edit freely
  159. skills/arena/rubric.md the five criteria every judge scores on
  160. tests/test_bracket.py the tests
  161. ```
  162. ## Credit
  163. Made by Jake Schincariol, [opusjake.ai](https://opusjake.ai).
  164. ## License
  165. MIT. Take it, change it, ship it.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.