name	code-search-selector
description	⚡ AUTO-INVOKE when user asks: 'audit', 'investigate', 'how does X work', 'find all', 'where is', 'trace', 'understand', 'map the codebase', 'comprehensive'. MUST run BEFORE Read/Glob when planning to read 3+ files. Prevents tool familiarity bias toward native tools.
allowed-tools	Bash, Read, AskUserQuestion

⛔ MANDATORY CODE SEARCH GATE ⛔

╔══════════════════════════════════════════════════════════════════════════════╗
║                                                                              ║
║   ⚡ THIS SKILL AUTO-TRIGGERS ON THESE KEYWORDS:                             ║
║                                                                              ║
║   "audit" | "investigate" | "how does X work" | "find all" | "where is"     ║
║   "trace" | "understand" | "map the codebase" | "comprehensive"              ║
║   "all integration points" | "find implementations" | "architecture"         ║
║                                                                              ║
║   🚫 INTERCEPTION: Triggers when about to Read 3+ files OR Glob broadly     ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

Why This Gate Exists

The Tool Familiarity Bias Problem:

You have "native" tools (Read, Glob, Grep) that are always available with predictable output. These feel safe. But they produce INFERIOR results for semantic queries.

The "Known File Path" Trap:

When a prompt mentions specific file paths, your instinct is to Read directly. RESIST THIS. Semantic search provides CONTEXT around those files that direct reads miss.

The Parallelization Excuse:

"Let me Read files while agents work" is inefficient. Claudemem's indexed data is FASTER and provides better context.

This skill ensures you use the RIGHT tool for code search tasks. Using Grep when claudemem is indexed is a critical mistake that produces inferior results.

The Problem This Solves

❌ WRONG: User asks "How does authentication work?"
   → You use: grep -r "auth" src/
   → Result: 500 lines of noise, no understanding

✅ RIGHT: User asks "How does authentication work?"
   → You check: claudemem status
   → You use: claudemem search "authentication login flow JWT"
   → Result: Top 10 semantically relevant code chunks

MANDATORY Decision Tree

Step 1: Classify the Task

┌─────────────────────────────────────────────────────────────────┐
│                    WHAT IS THE USER ASKING?                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  "Find all X"              → SEMANTIC (go to Step 2)            │
│  "How does X work"         → SEMANTIC (go to Step 2)            │
│  "Audit X integration"     → SEMANTIC (go to Step 2)            │
│  "Map the data flow"       → SEMANTIC (go to Step 2)            │
│  "Understand architecture" → SEMANTIC (go to Step 2)            │
│  "Trace X through code"    → SEMANTIC (go to Step 2)            │
│  "Find implementations"    → SEMANTIC (go to Step 2)            │
│  "What patterns are used"  → SEMANTIC (go to Step 2)            │
│                                                                  │
│  "Find exact string 'foo'" → EXACT MATCH (use Grep, skip tree)  │
│  "Count occurrences of X"  → EXACT MATCH (use Grep, skip tree)  │
│  "Find symbol UserService" → EXACT MATCH (use Grep, skip tree)  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Step 2: Check claudemem Status (MANDATORY for Semantic)

# ALWAYS run this before semantic search
claudemem status

Interpret the output:

Status	What It Means	Next Action
Shows chunk count (e.g., "938 chunks")	✅ Indexed	USE CLAUDEMEM (Step 3)
"No index found"	❌ Not indexed	Offer to index (Step 2b)
"command not found"	❌ Not installed	Fall back to Detective agent

Step 2b: If Not Indexed, Offer to Index

AskUserQuestion({
  questions: [{
    question: "Claudemem is not indexed. Index now for better semantic search results?",
    header: "Index?",
    multiSelect: false,
    options: [
      { label: "Yes, index now (Recommended)", description: "Takes 1-2 minutes, enables semantic search" },
      { label: "No, use grep instead", description: "Faster but less accurate for semantic queries" }
    ]
  }]
})

If user says yes:

claudemem index -y

Step 3: Execute the Search

IF CLAUDEMEM IS INDEXED (from Step 2):

# Get role-specific guidance first
claudemem ai developer  # or architect, tester, debugger

# Then search semantically
claudemem search "authentication login JWT token validation" -n 15

IF CLAUDEMEM IS NOT AVAILABLE:

Use the detective agent:

Task({
  subagent_type: "code-analysis:detective",
  description: "Investigate [topic]",
  prompt: "Use semantic search to find..."
})

Step 4: NEVER Do This

╔══════════════════════════════════════════════════════════════════╗
║  ❌ FORBIDDEN when claudemem is indexed:                         ║
║                                                                  ║
║  grep -r "pattern" src/          # Use claudemem search instead  ║
║  Grep tool for semantic queries  # Use claudemem search instead  ║
║  Glob to find implementations    # Use claudemem search instead  ║
║  find . -name "*.ts" | xargs...  # Use claudemem search instead  ║
║                                                                  ║
║  These tools are for EXACT MATCHES only, not semantic search.    ║
╚══════════════════════════════════════════════════════════════════╝

Task-to-Tool Mapping Reference

User Request	❌ DON'T Use	✅ DO Use
"Audit all API endpoints"	`grep -r "router\|endpoint"`	`claudemem search "API endpoint route handler"`
"How does auth work?"	`grep -r "auth\|login"`	`claudemem search "authentication login flow"`
"Find all database queries"	`grep -r "prisma\|query"`	`claudemem search "database query SQL prisma"`
"Map the data flow"	`grep -r "transform\|map"`	`claudemem search "data transformation pipeline"`
"What's the architecture?"	`ls -la src/`	`claudemem search "architecture layer service"`
"Find error handling"	`grep -r "catch\|error"`	`claudemem search "error handling exception"`
"Trace user creation"	`grep -r "createUser"`	`claudemem search "user creation registration"`

When Grep IS Appropriate

✅ Use Grep for:

Finding exact string: grep -r "DEPRECATED_FLAG" src/
Counting occurrences: grep -c "import React" src/**/*.tsx
Finding specific symbol: grep -r "class UserService" src/
Regex patterns: grep -r "TODO:\|FIXME:" src/

❌ Never use Grep for:

Understanding how something works
Finding implementations by concept
Architecture analysis
Tracing data flow
Auditing integrations

Integration with Detective Skills

After using this skill's decision tree, invoke the appropriate detective:

Investigation Type	Detective Skill
Architecture patterns	`code-analysis:architect-detective`
Implementation details	`code-analysis:developer-detective`
Test coverage	`code-analysis:tester-detective`
Bug root cause	`code-analysis:debugger-detective`
Comprehensive audit	`code-analysis:ultrathink-detective`

Quick Reference Card

┌─────────────────────────────────────────────────────────────────┐
│                    CODE SEARCH QUICK REFERENCE                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. ALWAYS check first:  claudemem status                       │
│                                                                  │
│  2. If indexed:          claudemem search "semantic query"       │
│                                                                  │
│  3. For exact matches:   Grep tool (only this case!)            │
│                                                                  │
│  4. For deep analysis:   Task(code-analysis:detective)          │
│                                                                  │
│  ⚠️ GREP IS FOR EXACT MATCHES, NOT SEMANTIC UNDERSTANDING       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Pre-Investigation Checklist

Before ANY code investigation task, verify:

Ran claudemem status to check index
Classified task as SEMANTIC or EXACT MATCH
Selected appropriate tool based on classification
NOT using grep for semantic queries when claudemem is indexed

🚫 MULTI-FILE READ INTERCEPTION

╔══════════════════════════════════════════════════════════════════════════════╗
║                        STOP BEFORE BULK FILE OPERATIONS                       ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  INTERCEPT TRIGGER: Before executing any of these:                           ║
║                                                                              ║
║  • Read 3+ files in same directory                                          ║
║  • Glob with broad patterns (**/*.ts, **/*.py)                              ║
║  • Sequential reads to "understand" a feature                               ║
║  • "Let me read files while agents work"                                    ║
║                                                                              ║
║  ASK YOURSELF:                                                               ║
║  1. Is claudemem indexed? (claudemem status)                                │
║  2. Can this be ONE semantic query instead of N file reads?                 ║
║  3. Am I falling into tool familiarity bias?                                ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

Interception Examples

❌ About to do:

Read src/services/auth/login.ts
Read src/services/auth/session.ts
Read src/services/auth/jwt.ts
Read src/services/auth/middleware.ts
Read src/services/auth/types.ts
Read src/services/auth/utils.ts

✅ Do instead:

claudemem search "authentication login session JWT middleware" -n 15

❌ About to do:

Glob pattern: src/services/prime/**/*.ts
Then read all 12 matches sequentially

✅ Do instead:

claudemem search "Prime API integration service endpoints" -n 20

❌ Parallelization trap:

"Let me Read these 5 files while the detective agent works..."

✅ Do instead:

Trust the detective agent to use claudemem.
Don't duplicate work with inferior Read/Glob.

🔴 ANTI-PATTERNS TO AVOID

Anti-Pattern	Why It's Wrong	Correct Alternative
Reading 5+ files sequentially	Token waste, no ranking	`claudemem search` once
Glob → Read all matches	No semantic understanding	`claudemem search` with concept
"Files mentioned, let me Read"	Misses context around files	Search semantically first
Grep for "how does X work"	Text match ≠ meaning	`claudemem search`
Read while agents work	Duplicate inferior work	Trust agent's claudemem usage

✅ CORRECT WORKFLOW

┌─────────────────────────────────────────────────────────────────┐
│                    CORRECT INVESTIGATION FLOW                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. TASK ARRIVES with keywords:                                 │
│     "audit", "investigate", "how does", "find all", etc.        │
│                                                                  │
│  2. AUTO-TRIGGER this skill (code-search-selector)              │
│                                                                  │
│  3. CHECK: claudemem status                                     │
│     • If indexed → Use claudemem search                         │
│     • If not → Index first OR launch detective agent            │
│                                                                  │
│  4. SEARCH SEMANTICALLY:                                        │
│     claudemem search "concept query" -n 15                      │
│                                                                  │
│  5. ONLY THEN Read specific files/lines from results            │
│                                                                  │
│  ⚠️ NEVER start with Read/Glob for semantic tasks               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Maintained by: MadAppGang Plugin: code-analysis v2.2.0 Purpose: Prevent tool familiarity bias, intercept multi-file reads, enforce semantic search

code-search-selector

Install Skill

SKILL.md

⛔ MANDATORY CODE SEARCH GATE ⛔

Why This Gate Exists

The Problem This Solves

MANDATORY Decision Tree

Step 1: Classify the Task

Step 2: Check claudemem Status (MANDATORY for Semantic)

Step 2b: If Not Indexed, Offer to Index

Step 3: Execute the Search

Step 4: NEVER Do This

Task-to-Tool Mapping Reference

When Grep IS Appropriate

Integration with Detective Skills

Quick Reference Card

Pre-Investigation Checklist

🚫 MULTI-FILE READ INTERCEPTION

Interception Examples

🔴 ANTI-PATTERNS TO AVOID

✅ CORRECT WORKFLOW