⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
arena
>-
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
The Arena skill
When Claude keeps giving you bad answers, make 100 versions of it fight to the death. One Claude Code skill. Free, MIT, no signup, no API key, nothing to connect.
You use it when you are not happy with what Claude gave you. Instead of asking again and again,
/arena spins up 100 sub-agents and gives every one of them the exact same task, word for word.
Each one gets a different strategy card: a way of reasoning, a workflow and a strategy, so each one
attacks the task differently. Then they pair off. Each attacks the other's solution, each defends
and revises its own, and a judge scores the match on a written rubric. The loser is out. 100
becomes 50, then 25, 13, 7, 4, 2, 1.
What comes back is the one solution that survived, the attacks it beat on the way, and how many rounds it took.
It never touches your files. Every sub-agent writes inside .arena/. The winning answer comes
back to you, and using it is your call.
Install
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.
Use it
/arena
/arena --quick write the headline for our pricing page
/arena --agents 32 fix the flaky test in tests/test_api.py
/arena --seed 7 plan my launch week, I have 6 hours a day
On its own, /arena takes your last request as the task and the answer you did not like as the one
to beat. Claude can also reach for it without the slash, when you say something like "that's a bad
answer, make them compete". When it starts itself like that, it asks before it spends anything.
| flag | what it does |
|---|---|
--agents N | N competitors. Default 100. |
--quick | 16 competitors. The everyday setting. |
--seed S | Same seed, same cards and same bracket. Default random, and recorded. |
--wave W | Sub-agents per wave. Default 10. Only raise it if you raised Claude Code's limit. |
How it works
- Spawn. N sub-agents, one Agent call each. Every one gets the same task text, byte for byte (a test checks it), plus one strategy card. There are 15 reasoning modes (first principles, inversion, analogy, adversarial, constraint first, worked example, Socratic, contrarian, systems thinking and more), 12 workflows (draft, critique, rewrite; outline first; test first; research, then synthesise; three drafts, pick one...) and 12 strategies (simplest thing that works, maximal rigour, user empathy first, edge cases first, speed...). That is 2,160 different cards. The dealer gives each agent its own, with no repeats.
- Attack. Solutions are paired, and the pairing avoids putting two agents with the same reasoning mode against each other. Each side attacks the other's solution through its own card: what is wrong, what requirement it missed, the exact input that breaks it. Up to 7 attacks, labelled FATAL, MAJOR or MINOR.
- Defend. Each side answers every attack it took, conceding or rebutting with evidence, then rewrites its solution to fix everything it conceded.
- Judge. A separate judge sub-agent reads both revised solutions, checks every attack itself,
and scores both on the rubric: correctness 30, completeness against the
task 25, robustness to the attacks raised 20, specificity 15, clarity 10. The judge never sees
the cards.
bracket.pydoes the arithmetic: the higher total goes through, and a solution with a verified fatal flaw cannot beat one without. The loser is out. - Repeat. The survivors carry their revised solutions into the next round. An odd number means one bye, never to the same agent twice while anyone else is waiting for one.
- Result. One solution left. You get it, the attacks it survived, its card and the round count. If you started from an answer you rejected, a last judge compares the winner with it blind and the skill tells you the score, even when the old answer wins.
The 100-agent bracket, from python3 skills/arena/bracket.py plan:
round alive matches bye sub-agent calls waves
spawn 100 - - 100 10
1 100 50 - 250 25
2 50 25 - 125 13
3 25 12 yes 60 8
4 13 6 yes 30 5
5 7 3 yes 15 3
6 4 2 - 10 3
7 2 1 - 5 3
total 595 70
alive per round: 100 -> 50 -> 25 -> 13 -> 7 -> 4 -> 2 -> 1
The whole tournament lives in one JSON file, managed by bracket.py. The main Claude session
only runs the loop and never reads the hundreds of solution files: every sub-agent writes its work
to disk and replies with one line, so the main context holds receipts and bookkeeping, not the
work. If the conversation gets compacted halfway through, bracket.py next picks it up from the
file.
What it costs
The skill is free. The tokens are yours, and 100 agents is a lot of them.
| agents | rounds | sub-agent calls | waves of 10 |
|---|---|---|---|
| 100, the default | 7 | 595 | 70 |
| 64 | 6 | 379 | 49 |
| 32 | 5 | 187 | 28 |
16, --quick | 4 | 91 | 16 |
| 8 | 3 | 43 | 10 |
Add one call when there is a rejected answer to beat. Every call reads the task and one or two
solutions, so the bill grows with the size of the task. Use --quick or --agents 16 for
everyday things and save the full 100 for the answer that matters. The skill prints these numbers
before it starts, and python3 skills/arena/bracket.py plan --agents N prints them any time.
The tool
bracket.py is standard-library Python. It is the reason the orchestrator never loses track.
python3 bracket.py plan --agents 100 # rounds, calls, waves. Writes nothing
python3 bracket.py init --agents 100 --seed 7 --task-file task.md [--baseline-file old.md]
python3 bracket.py next # what to do now, with the exact command
python3 bracket.py prompts attack # write every sub-agent brief, list the jobs in waves
python3 bracket.py pairings # this round's matches, including the bye
python3 bracket.py collect # record the judges' verdicts
python3 bracket.py record r3-m07 a042 --reason "..." # or record one by hand
python3 bracket.py advance # eliminate the losers, pair the survivors
python3 bracket.py status # alive and eliminated, per round
python3 bracket.py winner # the survivor, the attacks it survived, the rounds
The tests run a full 100-agent tournament through that command line with random winners and check it ends with exactly one survivor, plus 16, 7 and 1 agents, the dealer's guarantees, and every phase from spawn to the final check with stand-in sub-agents:
python3 -m unittest discover -s tests -v
The fine print
"100 versions of Claude" means 100 sub-agents of the model you are running. Not 100 different models. What makes them different is the card. The dealer guarantees that no two agents get the same card, that every reasoning mode, workflow and strategy is dealt as evenly as possible, and that up to 144 agents, no two agents even s
// HOW IT'S BUILT
// FILES
5 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/arena/SKILL.md19 KB559957505a56upstream ↗
--- name: arena description: >- Make 100 versions of Claude fight to the death over one task. Spins up N sub-agents (default 100, --quick for 16), gives every one the exact same task plus a different strategy card (reasoning mode, workflow, strategy), then runs a single-elimination bracket: they attack each other's solutions, defend and revise, and a judge scores every match on a written rubric until one solution survives. Use when the user is not satisfied with an answer, calls it a bad answer, says try again or do better, says "arena", or asks to make them compete. argument-hint: "[--agents N | --quick] [--seed S] <task>" --- # arena For when Claude keeps giving a bad answer. Instead of asking again and again, this runs a tournament: N sub-agents get the exact same task, each attacks it with a different reasoning mode, workflow and strategy, and then they attack each other in a bracket until one solution is left. You are the orchestrator. You never compete and you never judge. What the user typed after `/arena`: `$ARGUMENTS` If that is blank, or still reads like a placeholder, nothing was passed: take the task from the conversation. ## The tool Every piece of bookkeeping goes through `bracket.py` in this skill's folder: ```bash python3 "${CLAUDE_SKILL_DIR}/bracket.py" <command> ``` Below, `ARENA` means exactly that command. If the path looks unexpanded, use the "Base directory for this skill" that Claude Code printed at the top of this skill. The state lives in `.arena/<run>/arena.json` in the current directory, and every command after `init` finds it through `.arena/LATEST`. ## Step 1: size it, and get a yes if nobody asked for it Read the flags out of the request. Everything that is not a flag is the task. | flag | meaning | | --- | --- | | `--agents N` | N competitors. Default 100. | | `--quick` | 16 competitors. The everyday setting. | | `--seed S` | Fixes the cards and the pairings. Default: random, and recorded. | | `--wave W` | Sub-agents per wave. Default 10. Only raise it if the user raised Claude Code's limit. | No task text at all means: the task is the user's most recent request in this conversation, and your last answer to it is the baseline to beat. Run `ARENA plan --agents N` (or `--quick`). It prints the rounds, the sub-agent calls and the waves. - **The user asked for the arena** (typed `/arena`, said "arena", or asked to make them compete): tell them in one line how big it is, for example "100 agents, 7 rounds, 595 sub-agent calls", and start. - **This skill fired because the user is unhappy** ("that's wrong", "try again", "bad answer") and never mentioned the arena: ask once before spending anything. Offer three options: the full arena (100 agents, 595 sub-agent calls), `--quick` (16 agents, 91 calls), or an ordinary retry. Wait for the answer. Sub-agents write their work into `.arena/` in the current directory. In the default permission mode that is one approval per file, which is hundreds on a big run. Before the spawn phase, suggest accept-edits mode (Shift+Tab) for the run. Do not change the user's settings yourself. ## Step 2: write the task file This is the step that decides the result. **Sub-agents cannot see this conversation.** Every competitor, attacker and judge knows only what is in the task file, so write `.arena/task.md` to stand on its own: - The request, in the user's own words where you can. - Every requirement and constraint the user stated anywhere in the conversation: audience, length, format, tone, stack, deadline, what must not change. - The context a stranger would need: absolute paths of the files that matter, pasted data, what the product is, the conventions in the codebase. - What "done" looks like, if the user said. - If there is an answer to beat: what the user disliked about it, in their words. Do not add requirements the user never gave. Do not write your own view of the right answer into it: that pushes 100 agents the same way, which is the opposite of the point. If there is an earlier answer the user was not satisfied with, write it word for word to `.arena/baseline.md`. ## Step 3: init ```bash ARENA init --agents N --seed S --task-file .arena/task.md --baseline-file .arena/baseline.md ``` Leave out `--baseline-file` when there is nothing to beat, and `--seed` to get a random one. `init` copies the task into the run folder, deals every competitor a different strategy card with no repeats, pairs round 1, and writes `arena.json`. ## Step 4: the loop Always drive it with `ARENA next`. It reads the state on disk and tells you the next step and the exact command. Every phase that runs sub-agents works the same way: 1. `ARENA prompts <phase>` writes one brief per job and lists the jobs still to run, in waves. 2. Launch **one wave at a time**: a single message with one Agent tool call per job in that wave (the Agent tool is called Task in older Claude Code versions). Each call is: - `subagent_type`: `general-purpose` - `description`: `arena <job id>` - `prompt`: `Read <prompt path> and follow it exactly. It is your whole brief.` - `run_in_background`: false, where the tool has that option, so the wave comes back together. Wait until every agent in the wave has replied before you launch the next wave. 3. After the last wave, run `ARENA next`. If an output is missing it sends you back to the same phase, and `prompts` then lists only the missing jobs. Re-run those once. If a job fails twice, write the single line `NO OUTPUT` into each of its output files (`ARENA check <phase>` lists them) and move on. A missing attack counts as no attacks. A missing solution loses its match. A judge that fails twice gets a third, fresh run: never decide a match yourself. The order `next` takes you through: - **spawn**, once: every competitor writes its own solution to the task. - then every round: **attack** (two per match) → **defend** (two per match) → **judge** (one per match) → `ARENA collect` → `ARENA advance`. - **final**, once, only when there is a baseline: a judge compares the champion with the answer the user rejected, blind to which is which. Then `ARENA collect`. - `next` prints DONE: go to step 5. After each `advance`, give the user one line, such as "Round 2 done: 25 of 100 left." Nothing more. Never paste pairings, attacks, verdicts or solutions into the chat. Why waves: Claude Code runs at most 10 tool calls at once by default (the `CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY` setting). So a 100-agent spawn is 10 waves of 10, and a 100-agent arena is 70 waves in total, 71 with the final check. ## Step 5: the result Run `ARENA winner`, then read the champion's solution file at the path it prints. That is the only solution file you read in the whole run. Give the user: 1. **The winning solution**, in full. 2. **Why it won**: the attacks it survived, from `winner`, as a short list. Its card on one line (reasoning mode + workflow + strategy). 3. **Rounds**: for example "7 rounds, 100 agents in, 1 left." 4. **Against the answer you rejected**, if there was one: the final check's scores, honestly. If the old answer scored higher, say so plainly and show both. 5. Where the full record lives: the run folder. If the solution changes files in the user's project, do not apply it. Ask: apply it, or change it? ## Rules for the orchestrator - You run the tournament. You do not compete, attack or judge, and you never pick a winner. `collect` records what the judges decided. `record` is only for fixing bookkeeping when the user asks you to. - Every sub-agent gets the task through its brief, which `prompts` builds from the one task file, byte for byte the same for everyone. Never paraphrase the task for one agent or add a hint to one agent's call. - Do not read solutions, attacks or verdicts during the run. There are hundreds of them. The state is on disk, and `next`, `status` and `pairings` are all you need. - If your context gets compacted mid-run, nothing is lost. Run `ARENA status`, then `ARENA next`, and carry on. - Run every `ARENA` command from the directory you ran `init` in. That is where `.arena/LATEST` lives. - Sub-agents only write inside `.arena/`. If one wrote anywhere else, tell the user. - If the user says stop, stop. `ARENA status` shows where it got to, and `ARENA next` resumes it later. ## The prompt templates `bracket.py` fills these in (the `{{placeholders}}`) and writes one brief per job, so what you see here is exactly what every sub-agent is told. Never edit a brief for a single agent. ### Competitor, in the spawn phase <!-- template:competitor --> ```text You are competitor {{agent}} in an arena of {{n}}. All {{n}} competitors got the exact same task, word for word. The only thing that makes you different is the strategy card below: it decides how you attack the task. Your solution will be attacked by other competitors and scored by a judge, round after round, until one solution is left. === THE TASK (identical for every competitor) === {{task}} === END OF THE TASK === {{baseline_note}} === YOUR STRATEGY CARD === Reasoning mode: {{reasoning_name}}. {{reasoning_how}} Workflow: {{workflow_name}}. {{workflow_how}} Strategy: {{strategy_name}}. {{strategy_how}} === END OF THE CARD === How to work: 1. Use the card for real. Think in the reasoning mode, go through the workflow's steps in order, and let the strategy settle every trade-off. A generic answer with the card's name on top will lose. 2. Meet every requirement the task states. The judge scores you against the task, not against your card. 3. You cannot ask the user anything. Where the task is ambiguous, take the most reasonable reading and state it in a short Assumptions section. 4. Expect attacks: concrete flaws, counterexamples, missed requirements. Close those holes before you submit. 5. Do not create, edit or delete anything outside {{arena_dir}}. Read whatever the task points to. If the task is about code, put the exact changes in your solution (full files or a unified diff) instead of applying them. If your workflow needs scratch space, use {{arena_dir}}/scratch/{{agent}}/. Write your solution to {{out}}: the solution itself, written for the person who asked. Leave out your drafts and your working. Keep a checklist, tests or trade-off notes only where they help that person use the answer. Say nothing about the arena, your card or your competitor number: the judges score the work blind. When the file is written, reply with this one line and nothing else: DONE {{agent}} <number of words in your solution> ``` <!-- /template:competitor --> ### Attacker, in every round <!-- template:attacker --> ```text You are competitor {{agent}} in round {{round}} of an arena, match {{match}}. Your opponent is {{target}}. Only one of you gets out of this match. Right now your job is to attack your opponent's solution. === THE TASK (identical for every competitor) === {{task}} === END OF THE TASK === Your strategy card is the lens you look for flaws through: Reasoning mode: {{reasoning_name}}. {{reasoning_how}} Workflow: {{workflow_name}}. {{workflow_how}} Strategy: {{strategy_name}}. {{strategy_how}} Read your opponent's solution: {{target_solution}} You may read your own for comparison: {{own_solution}}. Attack theirs on its merits against the task, not for being different from yours. Find the real problems: - WRONG: factual errors, logic errors, bugs, false claims. - MISSING: a requirement the task states that it skips or only half meets. Quote the requirement. - BREAKS: a concrete input, scenario or edge case where it fails. Give the exact counterexample. - VAGUE: a place where the user could not act on it without guessing. Rules: - Every attack must be specific and checkable: point at the exact part, say what is wrong and why. - No praise, no summary, and no style nitpicks unless they stop the user from using it. - Do not invent requirements the task does not state. Do not attack the approach, only what it gets wrong. - At most 7 attacks, strongest first. If you only find 2 real ones, write 2. - Label each FATAL (wrong or unusable for the task), MAJOR (a real gap) or MINOR. - Do not create, edit or delete any file except the one below. Write the attacks to {{out}} in this format: ATTACK 1 [FATAL|MAJOR|MINOR] <one-line title> Where: <quote or location> Problem: <what is wrong, with the counterexample or the missed requirement> (and the same for each attack after that) When the file is written, reply with this one line and nothing else: ATTACKED {{target}} <number of attacks> (<number that are FATAL> fatal) ``` <!-- /template:attacker --> ### Defender, in every round <!-- template:defender --> ```text You are competitor {{agent}} in round {{round}} of an arena, match {{match}}. Your opponent {{attacker}} has attacked your solution. Now you defend it and revise it. A judge will score your revised solution against your opponent's, including how well each of you dealt with the attacks you took. === THE TASK (identical for every competitor) === {{task}} === END OF THE TASK === Your strategy card. Keep your approach: it is why you are still here. Reasoning mode: {{reasoning_name}}. {{reasoning_how}} Workflow: {{workflow_name}}. {{workflow_how}} Strategy: {{strategy_name}}. {{strategy_how}} Your current solution: {{own_solution}} The attacks against it: {{attacks}} Do this: 1. Take every attack in turn and decide honestly. CONCEDE if it is right, and fix it. REBUT if it is wrong, and show why with evidence from the task, your solution or a concrete check. A rebuttal that only insists you are right counts as a concession. Conceding a real flaw and fixing it scores better than defending it. 2. Write your revised solution: the complete solution, standalone, with every conceded point fixed. The judge reads only this file, so never write "see the previous version". Say nothing about the arena or your card. 3. Fix what was attacked and anything the attacks made you notice. Do not start again from scratch and do not copy your opponent. 4. If the attacks file is empty or says NO OUTPUT, you were not attacked: write NO ATTACKS RECEIVED as your defense, and resubmit your solution with only the fixes you know it needs. 5. Do not create, edit or delete anything outside {{arena_dir}}. Write your point-by-point defense to {{defense_out}} in this format: ATTACK 1: CONCEDE|REBUT. <one to three lines> (one entry per attack) Write your revised solution to {{solution_out}}. When both files are written, reply with this one line and nothing else: DEFENDED {{agent}} conceded <n> rebutted <n> ``` <!-- /template:defender --> ### Judge, one per match <!-- template:judge --> ```text You are the judge of match {{match}}, round {{round}}, in an arena. Two solutions to the same task have fought: each attacked the other, then defended and revised its own. Score both against the rubric. The one with the higher score goes through and the other is eliminated. === THE TASK (identical for every competitor) === {{task}} === END OF THE TASK === Read the rubric first: {{rubric}} Solution {{first}} - revised solution: {{first_solution}} - attacks it received: {{first_attacks}} - its defense: {{first_defense}} Solution {{second}} - revised solution: {{second_solution}} - attacks it received: {{second_attacks}} - its defense: {{second_defense}} How to judge: 1. Read both revised solutions in full before you score either one. 2. For every attack, check the revised solution yourself and call it FIXED, REBUTTED (only if the rebuttal is actually right) or STANDING. A defense that says "fixed" is not proof. Look. 3. Look for flaws the attackers missed, too. 4. Score each criterion from 0 to 10 using the rubric's anchors. Set fatal to true only for a flaw you have verified that makes the solution wrong or unusable for the task. 5. The winner is the higher weighted total (the weights are in the rubric). A fatal solution cannot beat one that is not fatal. On an exact tie, fewer standing attacks wins, then higher correctness. 6. Judge the work, not the writing about the work. Length is not quality. You do not know either competitor's strategy and should not guess it. 7. Do not create, edit or delete any file except the verdict. If the task is code and running something settles an attack, do it only inside {{arena_dir}}/scratch/judge-{{match}}/, never in the user's project. Write this JSON, and nothing else, to {{out}}: { "match": "{{match}}", "scores": { "{{first}}": {"correctness": 0, "completeness": 0, "specificity": 0, "robustness": 0, "clarity": 0, "fatal": false}, "{{second}}": {"correctness": 0, "completeness": 0, "specificity": 0, "robustness": 0, "clarity": 0, "fatal": false} }, "winner": "{{first}} or {{second}}", "reason": "one sentence: the decisive difference", "survived": ["each attack the winner took and beat, in a few words"], "standing": {"{{first}}": ["attacks still standing"], "{{second}}": ["attacks still standing"]} } When the file is written, reply with this one line and nothing else: WINNER <winner id> <winner total>-<loser total> ``` <!-- /template:judge --> ### Final check, only when there is an answer to beat <!-- template:final --> ```text You are the final check in an arena. {{n}} competitors fought over one task and a single solution survived {{rounds}} rounds. Before it goes back to the user, it is compared with the answer the user already rejected. You are not told which of the two is which. Score what is in front of you. Either one can win. === THE TASK === {{task}} === END OF THE TASK === Read the rubric first: {{rubric}} Solution X: {{x_solution}} Solution Y: {{y_solution}} How to judge: 1. Read both in full before you score either. 2. Attack both yourself: find the strongest concrete flaws in each, the way a hostile expert would. For the robustness score, judge how well each one holds up against those attacks. 3. Score each criterion from 0 to 10 using the rubric's anchors. Set fatal to true only for a flaw you have verified that makes a solution wrong or unusable for the task. 4. The winner is the higher weighted total. A fatal solution cannot beat one that is not fatal. 5. Judge the work, not the writing about the work. Length is not quality. 6. Do not create, edit or delete any file except the verdict. Write this JSON, and nothing else, to {{out}}: { "scores": { "X": {"correctness": 0, "completeness": 0, "specificity": 0, "robustness": 0, "clarity": 0, "fatal": false}, "Y": {"correctness": 0, "completeness": 0, "specificity": 0, "robustness": 0, "clarity": 0, "fatal": false} }, "winner": "X or Y", "reason": "one sentence: the decisive difference", "fixed": ["each thing the winner gets right that the other gets wrong, in a few words"] } When the file is written, reply with this one line and nothing else: FINAL <X or Y> <X total>-<Y total> ``` <!-- /template:final -->skills/arena/bracket.py48 KBe61810e7544cupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
skills/arena/rubric.md3.6 KB97a47160a8e5upstream ↗
# The arena rubric Every match in the arena is scored against this page. The judge scores both solutions, `bracket.py` does the arithmetic, and the higher weighted total goes through. The loser is out. ## The five criteria Each criterion is scored 0 to 10. The weight is how much of the 100-point total it is worth. | criterion | weight | the question | | --- | --- | --- | | Correctness | 30 | Is it right? No false claims, no logic errors, no bugs, nothing that would mislead the user. | | Completeness | 25 | Does it meet every requirement the task actually states? Judged against the task text, not against what the judge would have liked. | | Specificity | 15 | Could the user act on it right now without guessing? Exact steps, values, names, code. | | Robustness | 20 | Does it hold up against the attacks raised in this match? Fixed, correctly rebutted, or still standing. | | Clarity | 10 | Is it easy to read and use, at a length that fits the task? | Weighted total = (correctness x 30 + completeness x 25 + specificity x 15 + robustness x 20 + clarity x 10) / 10. That gives a number from 0 to 100. ## Anchors Use the whole scale. A 7 is not a polite default. **Correctness** - 10: nothing wrong that you can find after checking it yourself. - 7: minor slips that do not change the outcome for the user. - 4: at least one real error the user would trip on. - 0 to 2: wrong at the core, or it would cause harm if used. **Completeness** - 10: every stated requirement is met, fully. - 7: every requirement is touched, one is thin. - 4: a stated requirement is missing. - 0 to 2: it answers a different question from the one asked. **Specificity** - 10: the user can act on every part of it immediately. - 7: mostly concrete, with one or two places that need a guess. - 4: a lot of "consider", "ensure" and "it depends" without the actual answer. - 0 to 2: generic advice that would fit any task. **Robustness** - 10: every attack in this match is fixed in the revised solution or correctly rebutted, and nothing new is broken. - 7: one MINOR attack still standing. - 4: a MAJOR attack still standing, or a fix that broke something else. - 0 to 2: a FATAL attack still standing. A missing attack file means the opponent raised nothing. Score robustness on the flaws you found yourself. **Clarity** - 10: the shape makes it obvious how to use it. No padding. - 7: fine, with some padding or one confusing section. - 4: the user has to dig for the answer. - 0 to 2: hard to follow at all. ## The fatal rule Mark a solution `fatal` only when you have verified a flaw that makes it wrong or unusable for the task: code that cannot work, a false central claim, a hard constraint broken, the wrong question answered. A fatal solution cannot beat a solution that is not fatal, whatever the totals say. If both are fatal, the totals decide. ## Ties There are no draws. On an exact tie, the solution with fewer attacks still standing wins. If that is also level, the higher correctness score wins. If that is also level, pick the one you would hand to the user, and say why in the reason. ## What the judge does not reward - **Length.** Longer is not better. A tight answer that meets every requirement beats a long one that meets the same requirements. - **Confidence.** A defense that says "fixed" is not proof. Check the revised solution. - **The approach.** The judge never sees the strategy cards and does not guess at them. It scores the work, not the method that produced it. - **Talking about quality.** "This robust, comprehensive solution" earns nothing. The solution has to be robust and comprehensive. - **Agreement with the judge's own taste** where the task does not ask for it.skills/arena/strategies.json9.0 KBf5e3f28cf030upstream ↗
{ "version": 1, "about": "The strategy cards for /arena. Every competitor gets the same task and exactly one card: one reasoning mode, one workflow, one strategy. 15 x 12 x 12 = 2,160 distinct cards. bracket.py deals them with no repeats and spreads them evenly, so a 100-agent arena uses every reasoning mode, every workflow and every strategy. Edit freely: add an entry and the dealer picks it up. Ids must stay unique within a list.", "reasoning": [ { "id": "first-principles", "name": "First principles", "how": "Strip the task down to the facts and requirements nobody can argue with. Rebuild the answer from those alone, and keep a convention only if it earns its place again." }, { "id": "inversion", "name": "Inversion", "how": "Ask what would make this answer fail. List every way it could, then build the answer that makes each of those failures impossible." }, { "id": "analogy", "name": "Analogy", "how": "Find a problem in a different field that has already been solved and has the same shape. Port its solution over, then fix every place where the analogy breaks." }, { "id": "adversarial", "name": "Adversarial", "how": "Picture the harshest expert reviewer trying to tear the answer apart. Write their attacks down first and build the answer backwards from them." }, { "id": "constraint-first", "name": "Constraint first", "how": "List every hard constraint, stated and implied: time, budget, tools, format, audience, platform. Solve strictly inside that box and let the tightest constraint drive the design." }, { "id": "worked-example", "name": "Worked example", "how": "Solve one concrete, realistic instance end to end first, with real values. Generalise only from what that example actually taught you." }, { "id": "socratic", "name": "Socratic", "how": "Interrogate the task with the questions a sharp expert would ask before starting. Answer each one explicitly and let the answers decide the shape of the solution." }, { "id": "contrarian", "name": "Contrarian", "how": "Write down the obvious default answer, then argue seriously against it. Keep only what survives the argument, even if that takes you the unpopular way." }, { "id": "systems-thinking", "name": "Systems thinking", "how": "Map the moving parts, how they affect each other, and what happens second and third order. Optimise the whole system, not just the one part the task points at." }, { "id": "decomposition", "name": "Decomposition", "how": "Break the task into independent sub-problems. Solve each one completely, then integrate them and test the seams where they meet." }, { "id": "working-backwards", "name": "Working backwards", "how": "Describe the finished result precisely, as if it already exists. Then work backwards, step by step, to where the user is right now." }, { "id": "probabilistic", "name": "Probabilistic", "how": "Treat every claim and choice as uncertain. Weigh what is likely, prefer what holds up across most scenarios, and state your confidence where it changes the decision." }, { "id": "dialectical", "name": "Dialectical", "how": "State the strongest version of one answer, then the strongest opposing answer, then write the synthesis that keeps what is true in both." }, { "id": "evidence-first", "name": "Evidence first", "how": "Ground every claim in something checkable: the task text, the files it points to, the numbers given, documentation. Anything you cannot check gets labelled as an assumption." }, { "id": "expert-panel", "name": "Expert panel", "how": "Answer the task as three different experts would, picking roles that fit it. Take the strongest idea from each and settle every point where they disagree." } ], "workflows": [ { "id": "draft-critique-rewrite", "name": "Draft, critique, rewrite", "how": "Write a complete first draft. Critique it line by line against the task as if someone else wrote it. Then rewrite it from scratch using the critique." }, { "id": "outline-first", "name": "Outline first", "how": "Write a skeleton outline, check the outline against every requirement in the task, fix it, and only then fill it in." }, { "id": "test-first", "name": "Test first", "how": "Before writing the answer, write the checks it must pass: acceptance tests for code, pass or fail criteria for anything else. Then write the answer and run every check against it." }, { "id": "research-then-synthesise", "name": "Research, then synthesise", "how": "Gather every relevant fact first: the task, any files or context it points to, what is known about the domain. Write nothing until the research is done, then synthesise." }, { "id": "three-drafts", "name": "Three drafts, pick one", "how": "Write three short, genuinely different approaches. Pick the strongest on the task's own terms and develop only that one fully." }, { "id": "requirements-checklist", "name": "Requirements checklist", "how": "Pull every requirement out of the task into a numbered list. Solve, then tick each item off and say exactly where it is met." }, { "id": "iterative-deepening", "name": "Iterative deepening", "how": "Write a one-paragraph answer first. Then expand the parts that matter most in two more passes, each one deeper than the last." }, { "id": "build-then-break", "name": "Build, then break", "how": "Build the answer. Then throw five hostile inputs or scenarios at it, write down what breaks, and patch every break." }, { "id": "smallest-version-first", "name": "Smallest version first", "how": "Produce the smallest complete version that actually works. Then extend it one step at a time, keeping it working after every step." }, { "id": "options-matrix", "name": "Options matrix", "how": "List the realistic options, score them in a small matrix against the criteria that matter for this task, choose one, and write up the choice." }, { "id": "open-questions-first", "name": "Open questions first", "how": "List every open question the task leaves. Resolve each one with reasoning or a stated assumption, then answer." }, { "id": "write-then-restructure", "name": "Write, then restructure", "how": "Write freely and fast. Then outline what you actually wrote, fix the structure, and rewrite it to the new outline." } ], "strategies": [ { "id": "simplest", "name": "Simplest thing that works", "how": "Pick the least complicated answer that fully does the job. Every extra part has to justify itself." }, { "id": "maximal-rigour", "name": "Maximal rigour", "how": "Be exhaustive and exact. Check every step, verify every claim, and leave no hand-waving anywhere." }, { "id": "user-empathy", "name": "User empathy first", "how": "Start from the person who will use this: their situation, their skill level, and what they will actually do next. Shape everything around that." }, { "id": "edge-cases-first", "name": "Edge cases first", "how": "Hunt the edge cases, failure modes and weird inputs first, and design the answer around surviving them." }, { "id": "speed", "name": "Speed", "how": "Optimise for the fastest route to something usable today. Cut anything that does not move the result." }, { "id": "defensive", "name": "Defensive", "how": "Assume the inputs are bad and the conditions are hostile. Make the answer fail safely and loudly rather than quietly." }, { "id": "clarity", "name": "Clarity above all", "how": "Make it the easiest answer to read and act on: plain words, obvious structure, nothing the reader has to decode." }, { "id": "completeness", "name": "Completeness", "how": "Leave out nothing the task asks for or clearly implies. Cover every requirement explicitly." }, { "id": "fewest-moving-parts", "name": "Fewest moving parts", "how": "Remove things until it breaks, then put the last one back. Fewer steps, fewer dependencies, fewer words." }, { "id": "explicit-trade-offs", "name": "Explicit trade-offs", "how": "Name the real trade-offs, choose for the user's most likely constraints, and say plainly what that choice gives up." }, { "id": "built-to-last", "name": "Built to last", "how": "Optimise for how this holds up in six months: easy to maintain, easy to extend, no traps for the next person." }, { "id": "concrete-specifics", "name": "Concrete specifics", "how": "Exact numbers, names, commands, file paths and steps. Zero generic advice." } ] }README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/jakeschincariol-arena-skill-skills-arena.md