Agent-Skills.md

Agent Skills: Code Explorer - Deep Codebase Analyst

코드 탐색, 실행 흐름, 아키텍처 분석, 의존성 분석, 코드베이스 이해, 심볼 분석, 레퍼런스 추적 - Deeply analyzes codebase by tracing execution paths, mapping architecture layers, and using Serena MCP for symbol navigation. Use when exploring or understanding code.

UncategorizedID: aimskr/aims-toolkit/code-explorer

Repository

aimskr/aims-toolkit
aimskr

Install this agent skill to your local

pnpm dlx add-skill https://github.com/aimskr/aims-claude-toolkit/tree/HEAD/skills/code-explorer

Skill Files

Browse the full folder contents for code-explorer.

Download Skill

Loading file tree…

skills/code-explorer/SKILL.md

Skill Metadata

Name
code-explorer
Description
"코드 탐색, 실행 흐름, 아키텍처 분석, 의존성 분석, 코드베이스 이해, 심볼 분석, 레퍼런스 추적 - Deeply analyzes codebase by tracing execution paths, mapping architecture layers, and using Serena MCP for symbol navigation. Use when exploring or understanding code."

Code Explorer - Deep Codebase Analyst

Trace and understand feature implementations across codebases using Serena MCP and standard tools.

Tool Priority (Serena MCP First)

When Serena MCP is available:

  1. get_symbols_overview - First understand file structure
  2. find_symbol - Find specific classes, functions, variables
  3. find_referencing_symbols - Check where symbols are used
  4. search_for_pattern - Regex-based code search
  5. read_file - Only when above tools are insufficient

When Serena MCP is not available:

  1. Glob - Map file structure
  2. Grep - Search for patterns and symbols
  3. Read - Read specific files

Analysis Process

1. Structure Overview (get_symbols_overview / Glob)
   ↓
2. Entry Point Discovery (APIs, UI, CLI)
   ↓
3. Code Flow Tracing (symbol → references → call chain)
   ↓
4. Architecture Mapping (layers, patterns, dependencies)
   ↓
5. Report with file:line references

1. Feature Discovery

  • Find entry points (APIs, UI components, CLI commands)
  • Locate core implementation files
  • Map feature boundaries and configuration

2. Code Flow Tracing

  • Follow call chains from entry to output
  • Trace data transformations at each step
  • Identify all dependencies and integrations
  • Document state changes and side effects

3. Architecture Analysis

  • Map abstraction layers (presentation → business logic → data)
  • Identify design patterns and architectural decisions
  • Document interfaces between components
  • Note cross-cutting concerns (auth, logging, caching)

Output Format

Entry Points

| Type | Location | Description | |------|----------|-------------| | API | src/api/users.py:45 | GET /users endpoint |

Execution Flow

1. [Entry] src/api/users.py:45 - get_users()
   ↓ validates request params
2. [Service] src/services/user_service.py:30 - list_users()
   ↓ applies business rules
3. [Repository] src/repositories/user_repo.py:55 - find_all()
   ↓ builds query
4. [Response] returns domain objects

Key Components

| Component | File | Responsibility | |-----------|------|----------------| | Service | src/services/x.py | Business logic | | Repository | src/repositories/x.py | Data access |

Dependencies

  • Internal: module → module relationships
  • External: libraries and frameworks

Observations

  • Strengths: what's well designed
  • Issues/Tech Debt: problems found
  • Essential Files: ordered list for further reading

Principles

  1. Serena MCP first when available, then Glob/Grep/Read
  2. Always include file:line references
  3. Trace complete flow, not just surface level
  4. Identify patterns, not just code
  5. Note both strengths and issues

What to Avoid

  • Using read_file directly without understanding structure first
  • Reading entire files indiscriminately
  • Skipping symbol-level navigation when Serena is available