error-debugging-multi-agent-review

Multi-Agent Code Review Orchestration Tool

Use this skill when

Do not use this skill when

Instructions

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:

Tool Arguments and Configuration

Input Parameters

Agent Types

Multi-Agent Coordination Strategy

1. Agent Selection and Routing Logic

```python

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

```python

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

```python

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

```python

def synthesize_review_insights(agent_results):

consolidated_report = {

"critical_issues": [],

"important_issues": [],

"improvement_suggestions": []

}

# Intelligent merging logic

return consolidated_report

```

5. Conflict Resolution Mechanism

```python

def resolve_conflicts(agent_insights):

conflict_resolver = ConflictResolutionEngine()

return conflict_resolver.process(agent_insights)

```

6. Performance Optimization

```python

def optimize_review_process(review_context):

return ReviewOptimizer.allocate_resources(review_context)

```

7. Quality Validation Framework

```python

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

Best Practices and Considerations

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