error-debugging-multi-agent-review
/error-debugging-multi-agent-review
Coordinate specialized code, security, architecture, and performance reviewers and consolidate their results. Use when a codebase needs parallel review across multiple disciplines.
- Author
- rmyndharis ↗
- Repository
- antigravity-skills ↗
- Licence
- MIT
- Last repository change
- 07.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 07.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Coordinate specialized code, security, architecture, and performance reviewers and consolidate their results. Use when a codebase needs parallel review across multiple disciplines.
Original author description
Coordinate specialized code, security, architecture, and performance reviewers and consolidate their results. Use when a codebase needs parallel review across multiple disciplines.
How it works
- Use this skill when
- Do not use this skill when
- Instructions
- Role: Expert Multi-Agent Review Orchestration Specialist
- Context and Purpose
- Tool Arguments and Configuration
- Multi-Agent Coordination Strategy
- Example Implementations
- Reference Implementations
- Best Practices and Considerations
SKILL.md preview
---
name: error-debugging-multi-agent-review
description: "Coordinate specialized code, security, architecture, and performance reviewers and consolidate their results. Use when a codebase needs parallel review across multiple disciplines."
---
# 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.
## 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
- `[user request]`: Target code/project for review
- Supports: File paths, Git repositories, code snippets
- Handles multiple input formats
- Enables context extraction and agent routing
### Agent Types
1. Code Quality Reviewers
2. Security Auditors
3. Architecture Specialists
4. Performance Analysts
5. Compliance Validators
6. 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**:
```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
- **Contextual Intelligence**:
- Maintain shared context across agent interactions
- Pass refined insights between agents
- Support incremental review refinement
- **Context Propagation Model**:
```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
- **Hybrid Execution Strategy**:
- Parallel execution for independent reviews
- Sequential processing for dependent insights
- Intelligent timeout and fallback mechanisms
- **Execution Flow**:
```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
- **Intelligent Consolidation**:
- Merge insights from multiple agents
- Resolve conflicting recommendations
- Generate unified, prioritized report
- **Synthesis Algorithm**:
```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
- **Smart Conflict Handling**:
- Detect contradictory agent recommendations
- Apply weighted scoring
- Escalate complex conflicts
- **Resolution Strategy**:
```python
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**:
```python
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**:
```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
```python
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
```python
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
```python
hybrid_review_strategy = {
"parallel_agents": ["security", "performance"],
"sequential_agents": ["architecture", "compliance"]
}
```
## Reference Implementations
1. **Web Application Security Review**
2. **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: [user request]
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · rmyndharis/antigravity-skills | 100 | MIT |
| rootcastleco/rei-skills | 96 | MIT |
Database snapshot: 13.11.2026 · package version 5d19cc65be16 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100performance-testing-review-multi-agent-review
Coordinate specialized code, security, architecture, and performance reviewers and consolidate their results. Use when a codebase needs parallel review across multiple disciplines. - 100comprehensive-review-full-review
Coordinate code quality, architecture, security, performance, testing, and documentation reviews. Use when a change or codebase needs a consolidated assessment across these areas. - 84review-code
Review code changes for quality, security, and performance. Use when user says "review my changes", "do a code review", "check this for issues", "analyze code quality", "security review", "performance review", "is this PR ready", or needs architecture, security, performance, and style analysis. - 100github-code-review
Multi-agent code review for GitHub PRs. Use when reviewing a pull request, running security/performance/architecture/style checks on a diff, or coordinating specialized review agents and posting findings back to a PR. - 100code-review-senior
Senior code review skill. Analyze code changes for security, performance, code quality, architecture, and testing. Use when reviewing code changes. - 90code-review-and-quality
Conducts multi-axis code review across correctness, readability, architecture, security, and performance. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Triggers on "review my PR", "review this diff", "code review", "review…