---
name: Multi-Role Analysis
slug: multi-role-analysis
category: Quality
description: Multi-Role Analysis runs multiple specialized review roles (like security, performance, or frontend) in parallel against the same target and merges their findings into an integrated report. Use it when you want a multifaceted evaluation of code, plans, or designs in one command.
github: "https://github.com/wasabeef/claude-code-cookbook/tree/main/plugins/en/skills/multi-role"
language: Shell
stars: 1131
forks: 111
install: "npx degit https://github.com/wasabeef/claude-code-cookbook/tree/main/plugins/en/skills/multi-role ~/.claude/skills/multi-role"
installs_to: ~/.claude/skills/multi-role
source_path: plugins/en/skills/multi-role/SKILL.md
collection_size: 25
category_size: 1354
collection_url: "https://dirskills.com/collections/wasabeef/claude-code-cookbook"
added: 2026-08-20T07:56:19.403Z
last_synced: 2026-08-20T07:56:19.403Z
canonical_url: "https://dirskills.com/skills/multi-role-analysis"
---

# Multi-Role Analysis

Multi-Role Analysis runs multiple specialized review roles (like security, performance, or frontend) in parallel against the same target and merges their findings into an integrated report. Use it when you want a multifaceted evaluation of code, plans, or designs in one command.

**Install:**

```bash
npx degit https://github.com/wasabeef/claude-code-cookbook/tree/main/plugins/en/skills/multi-role ~/.claude/skills/multi-role
```

## README

# Parallel analysis with multiple roles and integrated report

A command that analyzes the same target in parallel with multiple roles and generates an integrated report.

## Usage

```bash
/multi-role <role1>,<role2> [--agent|-a] [analysis_target]
/multi-role <role1>,<role2>,<role3> [--agent|-a] [analysis_target]
```

## Available Roles

### Specialized Analysis Roles

- `security`: Security audit expert
- `performance`: Performance optimization expert
- `analyzer`: Root cause analysis expert
- `frontend`: Frontend and UI/UX expert
- `mobile`: Mobile development expert
- `backend`: Backend and server-side expert

### Development Support Roles

- `reviewer`: Code review expert
- `architect`: System architect
- `qa`: Test engineer

**Important**:

- Place the `--agent` option immediately after specifying roles
- Write your message after `--agent`
- Correct example: `/multi-role qa,architect --agent Evaluate the plan`
- Incorrect example: `/multi-role qa,architect Evaluate the plan --agent`

## Options

- `--agent` or `-a`: Execute each role as a sub-agent in parallel (recommended for large-scale analysis)
  - When using this option, if role descriptions include proactive delegation phrases (like "use PROACTIVELY"), more aggressive automatic delegation becomes enabled

## Basic Examples

```bash
# Dual analysis of security and performance (normal)
/multi-role security,performance
"Evaluate this API endpoint"

# Parallel analysis of large-scale system (sub-agents)
/multi-role security,performance --agent
"Comprehensively analyze system security and performance"

# Integrated analysis of frontend, mobile, and performance
/multi-role frontend,mobile,performance
"Consider optimization proposals for this screen"

# Multifaceted evaluation of architecture design (sub-agents)
/multi-role architect,security,performance --agent
"Evaluate microservices design"
```

## Analysis Process

## Phase 1: Parallel Analysis

Each role independently analyzes the same target

- Perform evaluation from specialized perspective
- Make judgments based on role-specific criteria
- Generate independent recommendations

## Phase 2: Integrated Analysis

Structure and integrate results

- Organize evaluation results from each role
- Identify overlaps and contradictions
- Clarify complementary relationships

## Phase 3: Integrated Report

Generate final recommendations

- Prioritized action plan
- Explicit trade-offs
- Implementation roadmap

## Output Format Examples

## For 2-role Analysis

```text
Multi-role Analysis: Security + Performance
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Analysis Target: API endpoint /api/users

Security Analysis Results:
Authentication: JWT verification properly implemented
Authorization: Role-based access control incomplete
Encryption: API keys logged in plain text

Evaluation Score: 65/100
Importance: High (due to sensitive data access)

Performance Analysis Results:
Response Time: Average 180ms (within target of 200ms)
Database Queries: N+1 problem detected
Caching: Redis cache not implemented

Evaluation Score: 70/100
Importance: Medium (currently within acceptable range)

Interrelated Analysis:
Synergistic Opportunities:
- Consider encryption when implementing Redis cache
- Improve logging for both security and performance gains

Trade-off Points:
- Authorization check strengthening ↔ Impact on response time
- Log encryption ↔ Reduced debugging efficiency

Integrated Priorities:
Critical: Fix API key plain text output
High: Resolve N+1 queries
Medium: Implement Redis cache + encryption
Low: Refine authorization control

Implementation Roadmap:
Week 1: Implement API key masking
Week 2: Database query optimization
Weeks 3-4: Cache layer design and implementation
Month 2: Progressive strengthening of authorization control
```

## For 3-role Analysis

```text
Multi-role Analysis: Frontend + Mobile + Performance
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Analysis Target: User Profile Screen

Frontend Analysis Results:
Usability: Intuitive layout
Accessibility: 85% WCAG 2.1 compliance
Responsive: Issues with tablet display

Mobile Analysis Results:
Touch Targets: 44pt+ ensured
One-handed Operation: Important buttons placed at top
Offline Support: Not implemented

Performance Analysis Results:
Initial Display: LCP 2.1s (good)
Image Optimization: WebP not supported
Lazy Loading: Not implemented

Integrated Recommendations:
1. Mobile optimization (one-handed operation + offline support)
2. Image optimization (WebP + lazy loading)
3. Tablet UI improvements

Priority: Mobile > Performance > Frontend
Implementation Period: 3-4 weeks
```

## Effective Combination Patterns

## Security-focused

```bash
/multi-role security,architect
"Authentication system design"

/multi-role security,frontend
"Login screen security"

/multi-role security,mobile
"Mobile app data protection"
```

## Performance-focused

```bash
/multi-role performance,architect
"Scalability design"

/multi-role performance,frontend
"Web page speed optimization"

/multi-role performance,mobile
"App performance optimization"
```

## User Experience-focused

```bash
/multi-role frontend,mobile
"Cross-platform UI"

/multi-role frontend,performance
"Balance between UX and performance"

/multi-role mobile,performance
"Mobile UX optimization"
```

## Comprehensive Analysis

```bash
/multi-role architect,security,performance
"Overall system evaluation"

/multi-role frontend,mobile,performance
"Comprehensive user experience evaluation"

/multi-role security,performance,mobile
"Comprehensive mobile app diagnosis"
```

## Collaboration with Claude

```bash
# Combine with file analysis
cat src/components/UserProfile.tsx
/multi-role frontend,mobile
"Evaluate this component from multiple perspectives"

# Evaluate design documents
cat architecture-design.md
/multi-role architect,security,performance
"Evaluate this design across multiple specialties"

# Error analysis
cat performance-issues.log
/multi-role performance,analyzer
"Analyze performance issues from multiple angles"
```

## Choosing between multi-role and role-debate

## When to use multi-role

- You want independent evaluations from each specialty
- You want to create an integrated improvement plan
- You want to organize contradictions and overlaps
- You want to determine implementation priorities

## When to use role-debate

- There are trade-offs between specialties
- Opinions might differ on technology selection
- You want to decide design policies through discussion
- You want to hear debates from different perspectives

## Sub-agent Parallel Execution (--agent)

Using the `--agent` option executes each role as an independent sub-agent in parallel.

### Promoting Automatic Delegation

If role file descriptions include phrases like these, more proactive automatic delegation is enabled when using `--agent`:

- "use PROACTIVELY"
- "MUST BE USED"
- Other emphasis expressions

### Execution Flow

```text
Normal execution:
Role 1 → Role 2 → Role 3 → Integration
(Sequential execution, approx. 3-5 minutes)

--agent execution:
Role 1 ─┐
Role 2 ─┼→ Integration
Role 3 ─┘
(Parallel execution, approx. 1-2 minutes)
```

### Effective Usage Examples

```bash
# Comprehensive evaluation of large-scale system
/multi-role architect,security,performance,qa --agent
"Comprehensive evaluation of new system"

# Detailed analysis from multiple perspectives
/multi-role frontend,mobile,performance --agent
"Full screen UX optimization analysis"
```

### Performance Comparison

| Number of Roles | Normal Execution | --agent Execution | Reduction Rate |
| --------------- | ---------------- | ----------------- | -------------- |
| 2 roles         | 2-3 minutes      | 1 minute          | 50%            |
| 3 roles         | 3-5 minutes      | 1-2 minutes       | 60%            |
| 4 roles         | 5-8 minutes      | 2-3 minutes       | 65%            |

## Notes

- Executing 3 or more roles simultaneously results in longer output
- Complex analyses may take longer to execute
- If conflicting recommendations arise, consider using role-debate
- Final judgments should be made by the user with reference to integrated results
- **When using --agent**: Consumes more resources but is efficient for large-scale analyses

## Role Configuration Details

- Detailed settings, domain expertise, and discussion traits for each role are defined in `.claude/agents/roles/`
- Includes Evidence-First practices and cognitive bias countermeasures
- Role-specific trigger phrases automatically enable the specialized mode