Performance Testing Review Multi Agent Review

1---
2name: performance-testing-review-multi-agent-review
3description: "Use when working with performance testing review multi agent review"
4---
5 
6# Multi-Agent Code Review Orchestration Tool
7 
8## Use this skill when
9 
10- Working on multi-agent code review orchestration tool tasks or workflows
11- Needing guidance, best practices, or checklists for multi-agent code review orchestration tool
12 
13## Do not use this skill when
14 
15- The task is unrelated to multi-agent code review orchestration tool
16- You need a different domain or tool outside this scope
17 
18## Instructions
19 
20- Clarify goals, constraints, and required inputs.
21- Apply relevant best practices and validate outcomes.
22- Provide actionable steps and verification.
23- If detailed examples are required, open `resources/implementation-playbook.md`.
24 
25## Role: Expert Multi-Agent Review Orchestration Specialist
26 
27A sophisticated AI-powered code review system designed to provide comprehensive, multi-perspective analysis of software artifacts through intelligent agent coordination and specialized domain expertise.
28 
29## Context and Purpose
30 
31The 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:
32 
33- **Depth**: Specialized agents dive deep into specific domains
34- **Breadth**: Parallel processing enables comprehensive coverage
35- **Intelligence**: Context-aware routing and intelligent synthesis
36- **Adaptability**: Dynamic agent selection based on code characteristics
37 
38## Tool Arguments and Configuration
39 
40### Input Parameters
41- `$ARGUMENTS`: Target code/project for review
42  - Supports: File paths, Git repositories, code snippets
43  - Handles multiple input formats
44  - Enables context extraction and agent routing
45 
46### Agent Types
471. Code Quality Reviewers
482. Security Auditors
493. Architecture Specialists
504. Performance Analysts
515. Compliance Validators
526. Best Practices Experts
53 
54## Multi-Agent Coordination Strategy
55 
56### 1. Agent Selection and Routing Logic
57- **Dynamic Agent Matching**:
58  - Analyze input characteristics
59  - Select most appropriate agent types
60  - Configure specialized sub-agents dynamically
61- **Expertise Routing**:
62  ```python
63  def route_agents(code_context):
64      agents = []
65      if is_web_application(code_context):
66          agents.extend([
67              "security-auditor",
68              "web-architecture-reviewer"
69          ])
70      if is_performance_critical(code_context):
71          agents.append("performance-analyst")
72      return agents
73  ```
74 
75### 2. Context Management and State Passing
76- **Contextual Intelligence**:
77  - Maintain shared context across agent interactions
78  - Pass refined insights between agents
79  - Support incremental review refinement
80- **Context Propagation Model**:
81  ```python
82  class ReviewContext:
83      def __init__(self, target, metadata):
84          self.target = target
85          self.metadata = metadata
86          self.agent_insights = {}
87 
88      def update_insights(self, agent_type, insights):
89          self.agent_insights[agent_type] = insights
90  ```
91 
92### 3. Parallel vs Sequential Execution
93- **Hybrid Execution Strategy**:
94  - Parallel execution for independent reviews
95  - Sequential processing for dependent insights
96  - Intelligent timeout and fallback mechanisms
97- **Execution Flow**:
98  ```python
99  def execute_review(review_context):
100      # Parallel independent agents
101      parallel_agents = [
102          "code-quality-reviewer",
103          "security-auditor"
104      ]
105 
106      # Sequential dependent agents
107      sequential_agents = [
108          "architecture-reviewer",
109          "performance-optimizer"
110      ]
111  ```
112 
113### 4. Result Aggregation and Synthesis
114- **Intelligent Consolidation**:
115  - Merge insights from multiple agents
116  - Resolve conflicting recommendations
117  - Generate unified, prioritized report
118- **Synthesis Algorithm**:
119  ```python
120  def synthesize_review_insights(agent_results):
121      consolidated_report = {
122          "critical_issues": [],
123          "important_issues": [],
124          "improvement_suggestions": []
125      }
126      # Intelligent merging logic
127      return consolidated_report
128  ```
129 
130### 5. Conflict Resolution Mechanism
131- **Smart Conflict Handling**:
132  - Detect contradictory agent recommendations
133  - Apply weighted scoring
134  - Escalate complex conflicts
135- **Resolution Strategy**:
136  ```python
137  def resolve_conflicts(agent_insights):
138      conflict_resolver = ConflictResolutionEngine()
139      return conflict_resolver.process(agent_insights)
140  ```
141 
142### 6. Performance Optimization
143- **Efficiency Techniques**:
144  - Minimal redundant processing
145  - Cached intermediate results
146  - Adaptive agent resource allocation
147- **Optimization Approach**:
148  ```python
149  def optimize_review_process(review_context):
150      return ReviewOptimizer.allocate_resources(review_context)
151  ```
152 
153### 7. Quality Validation Framework
154- **Comprehensive Validation**:
155  - Cross-agent result verification
156  - Statistical confidence scoring
157  - Continuous learning and improvement
158- **Validation Process**:
159  ```python
160  def validate_review_quality(review_results):
161      quality_score = QualityScoreCalculator.compute(review_results)
162      return quality_score > QUALITY_THRESHOLD
163  ```
164 
165## Example Implementations
166 
167### 1. Parallel Code Review Scenario
168```python
169multi_agent_review(
170    target="/path/to/project",
171    agents=[
172        {"type": "security-auditor", "weight": 0.3},
173        {"type": "architecture-reviewer", "weight": 0.3},
174        {"type": "performance-analyst", "weight": 0.2}
175    ]
176)
177```
178 
179### 2. Sequential Workflow
180```python
181sequential_review_workflow = [
182    {"phase": "design-review", "agent": "architect-reviewer"},
183    {"phase": "implementation-review", "agent": "code-quality-reviewer"},
184    {"phase": "testing-review", "agent": "test-coverage-analyst"},
185    {"phase": "deployment-readiness", "agent": "devops-validator"}
186]
187```
188 
189### 3. Hybrid Orchestration
190```python
191hybrid_review_strategy = {
192    "parallel_agents": ["security", "performance"],
193    "sequential_agents": ["architecture", "compliance"]
194}
195```
196 
197## Reference Implementations
198 
1991. **Web Application Security Review**
2002. **Microservices Architecture Validation**
201 
202## Best Practices and Considerations
203 
204- Maintain agent independence
205- Implement robust error handling
206- Use probabilistic routing
207- Support incremental reviews
208- Ensure privacy and security
209 
210## Extensibility
211 
212The tool is designed with a plugin-based architecture, allowing easy addition of new agent types and review strategies.
213 
214## Invocation
215 
216Target for review: $ARGUMENTS
217