cross-plugin-detective
This cross-plugin detective skill maps agents to appropriate investigation tools based on their roles, enabling developers, architects, and testers to analyze codebases through the code-analysis plugin. Use it when integrating multi-agent workflows that require role-specific code investigation, ensuring all detective queries use claudemem indexed memory searches rather than file system tools.
git clone --depth 1 https://github.com/MadAppGang/claude-code /tmp/cross-plugin-detective && cp -r /tmp/cross-plugin-detective/plugins/code-analysis/skills/cross-plugin-detective ~/.claude/skills/cross-plugin-detectiveSKILL.md
# Cross-Plugin Detective Integration
**Version:** 1.0.0
**Purpose:** Connect ANY agent to the appropriate detective skill based on role
## ⛔ CORE PRINCIPLE: INDEXED MEMORY ONLY
```
╔══════════════════════════════════════════════════════════════════════════════╗
║ ║
║ ALL DETECTIVE SKILLS USE claudemem (INDEXED MEMORY) EXCLUSIVELY ║
║ ║
║ When ANY agent references a detective skill, they MUST: ║
║ ❌ NEVER use grep, find, rg, Glob tool, Grep tool ║
║ ✅ ALWAYS use claudemem search "query" ║
║ ║
╚══════════════════════════════════════════════════════════════════════════════╝
```
---
## Agent-to-Skill Mapping
### Frontend Plugin Agents
| Agent | Should Use Skill | Purpose |
|-------|-----------------|---------|
| `typescript-frontend-dev` | `code-analysis:developer-detective` | Find implementations, trace data flow |
| `frontend-architect` | `code-analysis:architect-detective` | Analyze architecture, design patterns |
| `test-architect` | `code-analysis:tester-detective` | Coverage analysis, test quality |
| `senior-code-reviewer` | `code-analysis:ultrathink-detective` | Comprehensive code review |
| `ui-developer` | `code-analysis:developer-detective` | Find UI implementations |
| `designer` | `code-analysis:architect-detective` | Understand component structure |
| `plan-reviewer` | `code-analysis:architect-detective` | Review architecture plans |
### Bun Backend Plugin Agents
| Agent | Should Use Skill | Purpose |
|-------|-----------------|---------|
| `backend-developer` | `code-analysis:developer-detective` | Find implementations, trace data flow |
| `api-architect` | `code-analysis:architect-detective` | API architecture analysis |
| `apidog` | `code-analysis:developer-detective` | Find API implementations |
### Code Analysis Plugin Agents
| Agent | Should Use Skill | Purpose |
|-------|-----------------|---------|
| `codebase-detective` | All detective skills | Full investigation capability |
### Any Other Plugin
| Agent Role | Should Use Skill |
|------------|-----------------|
| Any "developer" agent | `code-analysis:developer-detective` |
| Any "architect" agent | `code-analysis:architect-detective` |
| Any "tester" agent | `code-analysis:tester-detective` |
| Any "reviewer" agent | `code-analysis:ultrathink-detective` |
| Any "debugger" agent | `code-analysis:debugger-detective` |
---
## How to Reference Skills in Agent Frontmatter
### Example: Developer Agent
```yaml
---
name: my-developer-agent
description: Implements features
skills: code-analysis:developer-detective
---
# My Developer Agent
When investigating code, use the developer-detective skill.
This gives you access to indexed memory search via claudemem.
## Investigation Pattern
Before implementing:
1. Check claudemem status: `claudemem status`
2. Search for related code: `claudemem search "feature I'm implementing"`
3. Read specific files from results
4. NEVER use grep or find for discovery
```
### Example: Architect Agent
```yaml
---
name: my-architect-agent
description: Designs architecture
skills: code-analysis:architect-detective
---
# My Architect Agent
When analyzing architecture, use the architect-detective skill.
## Architecture Discovery
1. Check claudemem status: `claudemem status`
2. Search for patterns: `claudemem search "service layer architecture"`
3. Map dependencies: `claudemem search "import dependency injection"`
4. NEVER use grep or find for discovery
```
### Example: Multi-Skill Agent
```yaml
---
name: comprehensive-reviewer
description: Reviews all aspects
skills: code-analysis:ultrathink-detective, code-analysis:tester-detective
---
```
---
## Skill Selection Decision Tree
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ WHICH DETECTIVE SKILL TO USE? │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ What is the agent's PRIMARY focus? │
│ │
│ ├── IMPLEMENTING code / Finding where to change │
│ │ └── Use: developer-detective │
│ │ │
│ ├── DESIGNING architecture / Understanding patterns │
│ │ └── Use: architect-detective │
│ │ │
│ ├── TESTING / Coverage analysis / Quality │
│ │ └── Use: tester-detective │
│ │ │
│ ├── DEBUGGING / Finding root cause │
│ │ └── Use: debugger-detective │
│ │ │
│ └── COMPREHENSIVE analysis / Technical debt / Audit │
│ └── Use: ultrathink-detective │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
---
## Integration Examples
### Example 1: Frontend Developer Agent Needing to Find Code
```typescript
// In frontend plugin's typescript-frontend-dev agent:
// ❌ WRONG - Never do this
Grep({ pattern: "UserService", type: "ts" });
Glob({ patArchitecture Decision Records (ADR) documentation practice. Use when documenting architectural decisions, recording technical trade-offs, creating decision logs, or establishing architectural patterns. Trigger keywords - "ADR", "architecture decision", "decision record", "trade-offs", "architectural decision", "decision log".
Use when deciding whether to launch an agent, selecting which agent to use, or coordinating multiple agents. Covers delegation criteria, external-model patterns, task isolation, and agent selection strategies.
Use when designing REST or GraphQL APIs, defining endpoints, implementing pagination/filtering, handling API versioning, or establishing API documentation with OpenAPI/Swagger.
Use when integrating Apidog + OpenAPI specifications with your React app. Covers MCP server setup, type generation, and query layer integration. Use when setting up API clients, generating types from OpenAPI, or integrating with Apidog MCP.
Analyzes API documentation from OpenAPI specs to provide TypeScript interfaces, request/response formats, and implementation guidance. Use when implementing API integrations, debugging API errors (400, 401, 404), replacing mock APIs, verifying data types, or when user mentions endpoints, API calls, or backend integration.
Use when analyzing architecture and system design. Find design patterns, map layers, identify core abstractions via PageRank. Uses claudemem AST structural analysis for efficient architecture investigation.
On-demand security and code quality audit. Use when checking for vulnerabilities, security issues, code smells, or compliance problems. Trigger keywords - "audit", "security check", "vulnerability scan", "code quality", "compliance", "security audit".
Use when implementing authentication (JWT, sessions, OAuth), authorization (RBAC, ABAC), password hashing, MFA, or security best practices for backend services.