Skillintermediate

/do-competitively - Competitive Multi-Agent Synthesis

Execute tasks through competitive multi-agent generation, meta-judge evaluation specification, multi-judge evaluation, and evidence-based synthesis to produce superior results.

Claude Code Knowledge Pack7/10/2026

Overview

/do-competitively - Competitive Multi-Agent Synthesis

Execute tasks through competitive multi-agent generation, meta-judge evaluation specification, multi-judge evaluation, and evidence-based synthesis to produce superior results.

Purpose - Generates multiple solutions competitively, evaluates with independent judges using meta-judge criteria, synthesizes best elements
Pattern - Generate-Critique-Synthesize (GCS) with meta-judge evaluation specification, self-critique, verification loops, and adaptive strategy selection
Output - Superior solution combining best elements from all candidates
Efficiency - 15-20% average cost savings through adaptive strategy (polish clear winners, redesign failures)

Quality Assurance

Enhanced verification with meta-judge tailored rubrics, Constitutional AI self-critique, Chain of Verification, and intelligent strategy selection

Pattern: Generate-Critique-Synthesize (GCS)

This command implements a four-phase adaptive competitive orchestration pattern with meta-judge evaluation specification and quality enhancement loops:

Phase 1: Competitive Generation with Self-Critique + Meta-Judge (IN PARALLEL)
         ┌─ Meta-Judge → Evaluation Specification YAML ───────────┐
Task ────┼─ Agent 2 → Draft → Critique → Revise → Solution B ───┐ │
         ├─ Agent 3 → Draft → Critique → Revise → Solution C ───┼─┤
         └─ Agent 1 → Draft → Critique → Revise → Solution A ───┘ │
                                                                  │
Phase 2: Multi-Judge Evaluation with Verification                 │
         ┌─ Judge 1 → Evaluate → Verify → Revise → Report A ─┐    │
         ├─ Judge 2 → Evaluate → Verify → Revise → Report B ─┼────┤
         └─ Judge 3 → Evaluate → Verify → Revise → Report C ─┘    │
                                                                  │
Phase 2.5: Adaptive Strategy Selection                            │
         Analyze Consensus ───────────────────────────────────────┤
                ├─ Clear Winner? → SELECT_AND_POLISH              │
                ├─ All Flawed (<3.0)? → REDESIGN (return Phase 1) │
                └─ Split Decision? → FULL_SYNTHESIS               │
                                          │                       │
Phase 3: Evidence-Based Synthesis         │                       │
         (Only if FULL_SYNTHESIS)         │                       │
         Synthesizer ─────────────────────┴───────────────────────┴─→ Final Solution

Usage

# Basic usage
/do-competitively <task-description>

# With explicit output specification
/do-competitively "Create authentication middleware" --output "src/middleware/auth.ts"

# With specific evaluation criteria
/do-competitively "Design user schema" --criteria "scalability,security,developer-experience"

Agent Types

Agent	Type	Phase	Role
Meta-Judge	`sadd:meta-judge`	Phase 1 (parallel)	Generates evaluation specification YAML (rubrics, checklists, scoring criteria) tailored to the task
Generator (x3)	default	Phase 1 (parallel)	Produces independent competitive solutions with self-critique
Judge (x3)	`sadd:judge`	Phase 2	Evaluates all solutions against meta-judge criteria
Synthesizer/Polisher (x1)	default	Phase 3	Combines or polishes based on adaptive strategy

When to Use

Use this command when:

Quality is critical - Multiple perspectives catch flaws single agents miss
Novel/ambiguous tasks - No clear "right answer", exploration needed
High-stakes decisions - Architecture choices, API design, critical algorithms
Learning/evaluation - Compare approaches to understand trade-offs
Avoiding local optima - Competitive generation explores solution space better

Do NOT use when:

Simple, well-defined tasks with obvious solutions
Time-sensitive changes
Trivial bug fixes or typos
Tasks with only one viable approach

Quality Enhancement Techniques

Techniques that were used to enhance the quality of the competitive execution pattern.

Phase	Technique	Benefit
Phase 1	Constitutional AI Self-Critique	Generators review and fix their own solutions before submission, catching 40-60% of issues
Phase 1/2	Meta-Judge Evaluation Specification	Meta-judge generates tailored rubrics, checklists, and scoring criteria in parallel with generators; judges use these instead of hardcoded criteria
Phase 2	Chain of Verification	Judges verify their evaluations with structured questions, improving calibration and reducing bias
Phase 2.5	Adaptive Strategy Selection	Orchestrator parses structured judge outputs (VOTE+SCORES) to select optimal strategy, saving 15-20% cost on average
Phase 3	Evidence-Based Synthesis	Combines proven best elements rather than creating new solutions (only when needed)

Theoretical Foundation

The competitive execution pattern combines insights from:

Academic Research:

Multi-Agent Debate (Du et al., 2023) - Diverse perspectives improve reasoning
Self-Consistency (Wang et al., 2022) - Multiple reasoning paths improve reliability
Tree of Thoughts (Yao et al., 2023) - Exploration of solution branches before commitment
Constitutional AI (Bai et al., 2022) - Self-critique loops catch 40-60% of issues before review
Chain-of-Verification (Dhuliawala et al., 2023) - Structured verification reduces bias
LLM-as-a-Judge (Zheng et al., 2023) - Structured evaluation rubrics

Engineering Practices:

Design Studio Method - Parallel design, critique, synthesis
Spike Solutions (XP/Agile) - Explore approaches, combine best
A/B Testing - Compare alternatives with clear metrics
Ensemble Methods - Combining multiple models improves performance