playbooks

home / skills / zpankz / mcp-skillset / analysis-router

analysis-router skill

/analysis-router

This skill helps you analyze and debug routes by guiding security, performance, and architecture assessments across analysis tasks.

npx playbooks add skill zpankz/mcp-skillset --skill analysis-router

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.3 KB
---
name: analysis-router
description: Routes analysis and debugging tasks. Triggers on analyze, debug, troubleshoot, review, audit, security, performance, optimize, investigate, trace.
---

# Analysis Router

Routes analysis, debugging, and review tasks to specialized skills.

## Subcategories

### Code Analysis
```yaml
triggers: [analyze, review, understand, trace, flow, structure]
skills:
  - sc:analyze: Code quality, security, performance, architecture analysis
  - systematic-debugging: Structured debugging approach
```

### Security Analysis
```yaml
triggers: [security, audit, vulnerability, injection, auth, permissions]
skills:
  - dev:security:security-audit: Security vulnerability scanning
  - dev:security:secure-prompts: Prompt injection defense
  - dev:security:check-best-practices: Security best practices
```

### Performance Analysis
```yaml
triggers: [performance, optimize, bottleneck, profiling, memory, speed]
skills:
  - sc:improve: Systematic improvements
  - parallel-debug-orchestrator: Parallel debugging
```

### Architecture Analysis
```yaml
triggers: [architecture, design, patterns, refactor, structure]
skills:
  - dev:architecture:explain-architecture-pattern: Pattern explanation
  - sc:design: System design
```

## Routing Decision Tree

```
analysis request
    │
    ├── Security focus?
    │   ├── Audit? → security-audit
    │   ├── Prompts? → secure-prompts
    │   └── Best practices → check-best-practices
    │
    ├── Performance focus?
    │   ├── Debugging? → parallel-debug-orchestrator
    │   └── Optimization → sc:improve
    │
    ├── Architecture focus?
    │   └── explain-architecture-pattern
    │
    └── General analysis?
        ├── Debugging? → systematic-debugging
        └── Review → sc:analyze
```

## Managed Skills

| Skill | Purpose | Trigger |
|-------|---------|---------|
| sc:analyze | Code analysis | "analyze code", "review" |
| systematic-debugging | Structured debug | "debug", "troubleshoot" |
| parallel-debug-orchestrator | Parallel debug | "complex bug", "multiple issues" |
| security-audit | Security scan | "security audit", "vulnerabilities" |
| secure-prompts | Prompt security | "prompt injection", "secure prompts" |
| sc:improve | Improvements | "improve", "optimize" |

Overview

This skill routes analysis, debugging, and review requests to specialized capabilities based on intent and focus. It detects security, performance, architecture, and general code-analysis needs and forwards tasks to the appropriate sub-skill. The router simplifies triage so callers get targeted, expert responses without manual categorization.

How this skill works

The router inspects the incoming request for trigger keywords and a stated focus (security, performance, architecture, debugging, review). It follows a decision tree to select a managed skill such as security-audit, parallel-debug-orchestrator, explain-architecture-pattern, systematic-debugging, or sc:analyze. When ambiguity exists, it defaults to general analysis and can request clarification.

When to use it

  • You need to direct an analysis or debugging request to the most appropriate specialist skill.
  • Triage incoming issue reports to determine security vs performance vs architecture focus.
  • Automate routing in chatbots or CI systems to ensure expert handling of audits, reviews, or optimizations.
  • Handle compound problems that may require parallel debugging or combined security and performance checks.
  • Reduce manual classification of tickets or requests for faster resolution.

Best practices

  • Include an explicit focus keyword (security, performance, architecture, debug, review) to improve routing accuracy.
  • Provide a short context snippet or error trace so the router can choose parallel vs systematic debugging appropriately.
  • Prefer concise, concrete prompts (e.g., "security audit for auth flow" or "profiling memory leak") over vague requests.
  • When the problem spans domains, tag all relevant focuses (security+performance) to enable multi-skill orchestration.
  • If routing is unclear, allow the router to ask a single clarifying question rather than guessing.

Example use cases

  • User asks "audit my auth endpoints for vulnerabilities" → routed to security-audit.
  • Developer reports "app slows under load, investigate bottleneck" → routed to sc:improve or parallel-debug-orchestrator for profiling.
  • Request: "trace data flow and explain architecture patterns" → routed to explain-architecture-pattern.
  • Ticket: "random crashes in production, help me debug" → routed to systematic-debugging or parallel-debug-orchestrator for complex cases.
  • Prompt: "check for prompt injection risks in user-facing prompts" → routed to secure-prompts.

FAQ

What happens if a request matches multiple focuses?

The router will prefer multi-skill orchestration or ask a clarifying question. If requested, it can run parallel routes (e.g., security and performance) to cover multiple angles.

Can I force a specific sub-skill?

Yes. Include the target skill name or an explicit instruction (e.g., "use security-audit") and the router will forward directly.