error-debugging-multi-agent-review

SKILL.md

Multi-Agent Code Review Orchestration Tool

Use this skill when

Working on multi-agent code review orchestration tool tasks or workflows

Needing guidance, best practices, or checklists for multi-agent code review orchestration tool

Do not use this skill when

The task is unrelated to multi-agent code review orchestration tool

You need a different domain or tool outside this scope

Instructions

Clarify goals, constraints, and required inputs.

Apply relevant best practices and validate outcomes.

Provide actionable steps and verification.

If detailed examples are required, open resources/implementation-playbook.md.

Role: Expert Multi-Agent Review Orchestration Specialist

A sophisticated AI-powered code review system designed to provide comprehensive, multi-perspective analysis of software artifacts through intelligent agent coordination and specialized domain expertise.

Context and Purpose

The Multi-Agent Review Tool leverages a distributed, specialized agent network to perform holistic code assessments that transcend traditional single-perspective review approaches. By coordinating agents with distinct expertise, we generate a comprehensive evaluation that captures nuanced insights across multiple critical dimensions:

Depth: Specialized agents dive deep into specific domains

Breadth: Parallel processing enables comprehensive coverage

Intelligence: Context-aware routing and intelligent synthesis

Adaptability: Dynamic agent selection based on code characteristics

Tool Arguments and Configuration

Input Parameters

$ARGUMENTS: Target code/project for review

Supports: File paths, Git repositories, code snippets

Handles multiple input formats

Enables context extraction and agent routing

Agent Types

Code Quality Reviewers

Security Auditors

Architecture Specialists

Performance Analysts

Compliance Validators

Best Practices Experts

Multi-Agent Coordination Strategy

1. Agent Selection and Routing Logic

Dynamic Agent Matching:

Analyze input characteristics

Select most appropriate agent types

Configure specialized sub-agents dynamically

Expertise Routing:
def route_agents(code_context):
    agents = []
    if is_web_application(code_context):
        agents.extend([
            "security-auditor",
            "web-architecture-reviewer"
        ])
    if is_performance_critical(code_context):
        agents.append("performance-analyst")
    return agents

2. Context Management and State Passing

Contextual Intelligence:

Maintain shared context across agent interactions

Pass refined insights between agents

Support incremental review refinement

Context Propagation Model:
class ReviewContext:
    def __init__(self, target, metadata):
        self.target = target
        self.metadata = metadata
        self.agent_insights = {}

    def update_insights(self, agent_type, insights):
        self.agent_insights[agent_type] = insights

3. Parallel vs Sequential Execution

Hybrid Execution Strategy:

Parallel execution for independent reviews

Sequential processing for dependent insights

Intelligent timeout and fallback mechanisms

Execution Flow:
def execute_review(review_context):
    # Parallel independent agents
    parallel_agents = [
        "code-quality-reviewer",
        "security-auditor"
    ]

    # Sequential dependent agents
    sequential_agents = [
        "architecture-reviewer",
        "performance-optimizer"
    ]

4. Result Aggregation and Synthesis

Intelligent Consolidation:

Merge insights from multiple agents

Resolve conflicting recommendations

Generate unified, prioritized report

Synthesis Algorithm:
def synthesize_review_insights(agent_results):
    consolidated_report = {
        "critical_issues": [],
        "important_issues": [],
        "improvement_suggestions": []
    }
    # Intelligent merging logic
    return consolidated_report

5. Conflict Resolution Mechanism

Smart Conflict Handling:

Detect contradictory agent recommendations

Apply weighted scoring

Escalate complex conflicts

Resolution Strategy:
def resolve_conflicts(agent_insights):
    conflict_resolver = ConflictResolutionEngine()
    return conflict_resolver.process(agent_insights)

6. Performance Optimization

Efficiency Techniques:

Minimal redundant processing

Cached intermediate results

Adaptive agent resource allocation

Optimization Approach:
def optimize_review_process(review_context):
    return ReviewOptimizer.allocate_resources(review_context)

7. Quality Validation Framework

Comprehensive Validation:

Cross-agent result verification

Statistical confidence scoring

Continuous learning and improvement

Validation Process:
def validate_review_quality(review_results):
    quality_score = QualityScoreCalculator.compute(review_results)
    return quality_score > QUALITY_THRESHOLD

Example Implementations

1. Parallel Code Review Scenario

multi_agent_review(
    target="/path/to/project",
    agents=[
        {"type": "security-auditor", "weight": 0.3},
        {"type": "architecture-reviewer", "weight": 0.3},
        {"type": "performance-analyst", "weight": 0.2}
    ]
)

2. Sequential Workflow

sequential_review_workflow = [
    {"phase": "design-review", "agent": "architect-reviewer"},
    {"phase": "implementation-review", "agent": "code-quality-reviewer"},
    {"phase": "testing-review", "agent": "test-coverage-analyst"},
    {"phase": "deployment-readiness", "agent": "devops-validator"}
]

3. Hybrid Orchestration

hybrid_review_strategy = {
    "parallel_agents": ["security", "performance"],
    "sequential_agents": ["architecture", "compliance"]
}

Reference Implementations

Web Application Security Review

Microservices Architecture Validation

Best Practices and Considerations

Maintain agent independence

Implement robust error handling

Use probabilistic routing

Support incremental reviews

Ensure privacy and security

Extensibility

The tool is designed with a plugin-based architecture, allowing easy addition of new agent types and review strategies.

Invocation

Target for review: $ARGUMENTS

Limitations

Use this skill only when the task clearly matches the scope described above.

Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.