Agent-Skills.md

Agent Skills: Cross-Plugin Detective Integration

Use when integrating detective skills across plugins. Maps agent roles to appropriate detective skills (developer → developer-detective, architect → architect-detective). Reference this to connect agents with claudemem investigation capabilities.

UncategorizedID: madappgang/claude-code/cross-plugin-detective

Repository

madappgang/claude-code
MadAppGangLicense: MIT
24826

Install this agent skill to your local

pnpm dlx add-skill https://github.com/MadAppGang/claude-code/tree/HEAD/plugins/code-analysis/skills/cross-plugin-detective

Skill Files

Browse the full folder contents for cross-plugin-detective.

Download Skill

Loading file tree…

plugins/code-analysis/skills/cross-plugin-detective/SKILL.md

Skill Metadata

Name
cross-plugin-detective
Description
Use when integrating detective skills across plugins. Maps agent roles to appropriate detective skills (developer → developer-detective, architect → architect-detective). Reference this to connect agents with claudemem investigation capabilities.

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

---
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

---
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

---
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

// In frontend plugin's typescript-frontend-dev agent:

// ❌ WRONG - Never do this
Grep({ pattern: "UserService", type: "ts" });
Glob({ pattern: "**/user*.ts" });

// ✅ CORRECT - Use indexed memory via developer-detective skill
// The skill teaches the agent to use:
claudemem search "UserService implementation methods"

Example 2: Backend Architect Analyzing API Structure

// In bun plugin's api-architect agent:

// ❌ WRONG - Never do this
find . -name "*.controller.ts"
grep -r "router\." . --include="*.ts"

// ✅ CORRECT - Use indexed memory via architect-detective skill
claudemem search "API controller endpoint handler"
claudemem search "router pattern REST GraphQL"

Example 3: Test Architect Finding Coverage Gaps

// In frontend plugin's test-architect agent:

// ❌ WRONG - Never do this
Glob({ pattern: "**/*.test.ts" });
Grep({ pattern: "describe" });

// ✅ CORRECT - Use indexed memory via tester-detective skill
claudemem search "test coverage describe spec"
claudemem search "mock stub test assertion"

Skill Inheritance Pattern

When an agent needs code investigation, it should:

  1. Reference the appropriate detective skill in frontmatter
  2. Follow the skill's INDEXED MEMORY ONLY requirement
  3. Use claudemem for ALL code discovery
  4. NEVER fall back to grep/find/Glob/Grep tools
---
name: any-agent-that-needs-investigation
skills: code-analysis:developer-detective  # or architect/tester/debugger/ultrathink
---

# This agent inherits:
# - INDEXED MEMORY requirement (claudemem only)
# - Role-specific search patterns
# - Output format guidance
# - FORBIDDEN: grep, find, Glob, Grep tools

Plugin Dependencies

If your plugin has agents that need code investigation, add this dependency:

{
  "name": "your-plugin",
  "dependencies": {
    "code-analysis@mag-claude-plugins": "^1.6.0"
  }
}

This ensures:

  • claudemem skills are available
  • Detective skills are accessible via code-analysis:* prefix
  • Agents can reference skills in frontmatter

Summary: The Golden Rule

╔══════════════════════════════════════════════════════════════════════════════╗
║                                                                              ║
║   ANY AGENT + CODE INVESTIGATION = claudemem ONLY                            ║
║                                                                              ║
║   Developer agents → code-analysis:developer-detective                       ║
║   Architect agents → code-analysis:architect-detective                       ║
║   Tester agents    → code-analysis:tester-detective                          ║
║   Debugger agents  → code-analysis:debugger-detective                        ║
║   Reviewer agents  → code-analysis:ultrathink-detective                      ║
║                                                                              ║
║   grep/find/Glob/Grep = FORBIDDEN (always, everywhere, no exceptions)        ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

Maintained by: MadAppGang Plugin: code-analysis Last Updated: December 2025