home / skills / yeachan-heo / oh-my-claudecode / deepsearch

deepsearch skill

safe

This skill performs thorough codebase search and synthesis across files, imports, and usage patterns to identify core implementations and connections.

npx playbooks add skill yeachan-heo/oh-my-claudecode --skill deepsearch

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

Files (1)

SKILL.md

980 B

---
name: deepsearch
description: Thorough codebase search
---

# Deep Search Mode

[DEEPSEARCH MODE ACTIVATED]

## Objective

Perform thorough search of the codebase for the specified query, pattern, or concept.

## Search Strategy

1. **Broad Search**
   - Search for exact matches
   - Search for related terms and variations
   - Check common locations (components, utils, services, hooks)

2. **Deep Dive**
   - Read files with matches
   - Check imports/exports to find connections
   - Follow the trail (what imports this? what does this import?)

3. **Synthesize**
   - Map out where the concept is used
   - Identify the main implementation
   - Note related functionality

## Output Format

- **Primary Locations** (main implementations)
- **Related Files** (dependencies, consumers)
- **Usage Patterns** (how it's used across the codebase)
- **Key Insights** (patterns, conventions, gotchas)

Focus on being comprehensive but concise. Cite file paths and line numbers.

Overview

This skill performs a thorough, codebase-wide search for a specified query, pattern, or concept and produces a concise map of findings. It targets primary implementations, related files, usage patterns, and actionable insights to speed triage and refactor work. The output emphasizes file paths, line ranges, and synthesis rather than raw results dump.

How this skill works

It runs a multi-stage search: broad text matches, term variations, and focused scans of common locations like components, utils, services, and hooks. Matched files are read to follow import/export chains and call graphs to discover consumers and dependencies. Results are synthesized into primary locations, related files, usage patterns, and key insights with file paths and line numbers.

When to use it

When you need to locate the canonical implementation of a feature across a large TypeScript codebase.
When debugging unexpected behavior and you must find all consumers of a function, constant, or component.
Before refactoring to understand coupling and side effects across modules.
When onboarding or documenting a code area and you need a compact map of where things live.
To verify that a concept or API is not duplicated or shadowed in multiple locations.

Best practices

Start with an exact identifier, then expand to likely variations and synonyms to avoid missed results.
Prioritize files by import graph depth—follow who imports the matched module to find true consumers.
Capture file paths and line ranges for each hit to make verification and code review quick.
Note common patterns and anti-patterns (naming, side effects, duplicated logic) for refactor planning.
Use the synthesized insights to build targeted tests or smaller follow-up searches rather than repeating broad scans.

Example use cases

Find the single source of truth for a configuration key and list all modules that read or override it.
Trace where a React hook or utility is used to assess the impact of changing its signature.
Locate every usage of a deprecated API to prepare a migration plan with precise edit locations.
Map the consumers of a service class to identify candidates for extraction or isolation.
Quickly validate whether similar implementations exist to avoid introducing duplicate logic during a feature add.

FAQ

How granular are the reported locations?

Results include file paths and specific line ranges where matches occur so you can jump directly to relevant code.

Does it handle TypeScript import/export resolution?

Yes—after text matches it follows import/export chains to identify actual module providers and consumers.

Will it return too many false positives?

The search starts broad and then filters by contextual analysis (imports, call sites) to reduce noise; you can tune term variants.