arena_skill

Overview

This skill orchestrates external coding engines to deliver implementations via two paradigms: COMPETE (multiple approaches compared to pick the best) and COLLABORATE (divide a task and integrate engine-specialized outputs). It supports Solo, Team, and Quick execution modes and invokes codex exec and gemini CLI directly through Bash. The workflow emphasizes locked scope, measurable evaluation, and verification before adoption.

How this skill works

Arena prepares a clear specification and locks the allowed file scope, then invokes external engines directly (codex/gemini) using CLI. In COMPETE, Arena generates multiple variants on isolated branches, runs automated reviews and weighted scoring, and selects or hybridizes the best result. In COLLABORATE, it decomposes the task, assigns non-overlapping subtasks to engines in parallel, integrates outputs, and verifies build, tests, and interfaces.

When to use it

• When multiple valid technical approaches exist and you need evidence-based selection (COMPETE).
• When a complex feature can be partitioned and each engine’s strengths fit a subtask (COLLABORATE).
• When you want quick experiments limited to a few small files or criteria (Quick mode).
• When parallel execution across agents speeds discovery and you can manage worktrees (Team mode).
• When you must avoid unilateral engine changes to configuration, deps, or unrelated files.

Best practices

• Define a precise spec and lock allowed/forbidden files before any run.
• Choose paradigm first: COMPETE for comparison, COLLABORATE for decomposition. Don’t mix responsibilities mid-run.
• Use Git branches/worktrees for isolation and traceability; name branches per variant/task.
• Set concrete evaluation criteria and weights (correctness, quality, performance, safety, simplicity).
• Run automated quality reviews and verify build/tests before merging or adopting.
• Ask user decisions at key triggers (paradigm, mode, engine count, cost thresholds).

Example use cases

• Compare three bug-fix approaches across engines to select the safest, fastest patch (COMPETE Team).
• Split a new API feature into schema, backend, and client subtasks and assign engines to each, then integrate (COLLABORATE Solo/Team).
• Run a quick two-variant comparison for a ≤50-line refactor to get a fast, evidence-backed choice (Quick).
• Use self-competition with one engine to explore different prompt styles or model variants when only one engine is available.
• Coordinate with upstream agents (Sherpa/Scout/Spark) to accept decompositions or issue investigations and hand off verified artifacts to downstream agents (Guardian/Radar).