explore-codebase
Pattern for efficiently exploring codebases using parallel subagents. Use when you need to understand code structure, find patterns, or gather context.
Best use case
explore-codebase is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Pattern for efficiently exploring codebases using parallel subagents. Use when you need to understand code structure, find patterns, or gather context.
Teams using explore-codebase should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/explore-codebase/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How explore-codebase Compares
| Feature / Agent | explore-codebase | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Pattern for efficiently exploring codebases using parallel subagents. Use when you need to understand code structure, find patterns, or gather context.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Explore Codebase Skill
Pattern for exploring codebases efficiently with parallel subagents.
## When to Load This Skill
- You need to understand parts of the codebase
- You're gathering context before making decisions
- You need to find patterns, conventions, or existing implementations
## Exploration Strategy
### For Quick Searches (Do Yourself)
```
Glob("**/*{keyword}*")
Grep(pattern="functionName", type="ts")
```
Use when looking for a specific thing.
### For Broad Understanding (Spawn Explorers)
Spawn parallel explorer subagents:
```
Task(
subagent_type: "explorer", # Custom dotagent agent (lowercase)
model: "haiku",
prompt: |
Query: {specific question}
Hints: {where to look}
Scope: {limit if needed}
Return structured YAML:
- findings (location, relevance, summary)
- patterns_observed
- related_areas
- gaps
)
```
Spawn multiple for different areas simultaneously.
**Note:** Use `"explorer"` (lowercase) for the custom dotagent agent defined in
`@.claude/agents/explorer.md`. The built-in `"Explore"` (capitalized) is a different
Claude Code agent with simpler behavior.
### Synthesize Results
Combine explorer outputs into coherent understanding:
- Common patterns across areas
- Integration points
- Constraints discovered
- Gaps to note
## Output Format
After exploration, summarize as:
```yaml
codebase_context:
architecture_summary: string
existing_patterns: [string]
integration_points: [string]
constraints: [string]
gaps: [string]
```
## Principles
- **Parallel over sequential** - Spawn multiple explorers at once
- **Breadth over depth** - Explore broadly first
- **Structured output** - Always produce YAML summaries
- **Note gaps** - What you couldn't find mattersRelated Skills
cursor-codebase-indexing
Set up and optimize Cursor codebase indexing for semantic code search and @Codebase queries. Triggers on "cursor index", "codebase indexing", "index codebase", "cursor semantic search", "@codebase", "cursor embeddings".
playwright-explore-website
Website exploration for testing using Playwright MCP
generate-custom-instructions-from-codebase
Migration and code evolution instructions generator for GitHub Copilot. Analyzes differences between two project versions (branches, commits, or releases) to create precise instructions allowing Copilot to maintain consistency during technology migrations, major refactoring, or framework version upgrades.
codebase-search
Search and navigate large codebases efficiently. Use when finding specific code patterns, tracing function calls, understanding code structure, or locating bugs. Handles semantic search, grep patterns, AST analysis.
codebase-cleanup-tech-debt
You are a technical debt expert specializing in identifying, quantifying, and prioritizing technical debt in software projects. Analyze the codebase to uncover debt, assess its impact, and create acti
codebase-cleanup-refactor-clean
You are a code refactoring expert specializing in clean code principles, SOLID design patterns, and modern software engineering best practices. Analyze and refactor the provided code to improve its quality, maintainability, and performance.
codebase-cleanup-deps-audit
You are a dependency security expert specializing in vulnerability scanning, license compliance, and supply chain security. Analyze project dependencies for known vulnerabilities, licensing issues, outdated packages, and provide actionable remediation strategies.
lark-openapi-explorer
飞书/Lark 原生 OpenAPI 探索：从官方文档库中挖掘未经 CLI 封装的原生 OpenAPI 接口。当用户的需求无法被现有 lark-* skill 或 lark-cli 已注册命令满足，需要查找并调用原生飞书 OpenAPI 时使用。
codebase-mapping
Repository structure and dependency analysis for understanding a codebase's architecture. Use when needing to (1) generate a file tree or structure map, (2) analyze import/dependency graphs, (3) identify entry points and module boundaries, (4) understand the overall layout of an unfamiliar codebase, or (5) prepare for deeper architectural analysis.
investigating-codebases
Automatically activated when user asks how something works, wants to understand unfamiliar code, needs to explore a new codebase, or asks questions like "where is X implemented?", "how does Y work?", or "explain the Z component"
codebase-analysis
Systematically analyze codebase structure, complexity, dependencies, and architectural patterns to understand project organization
codebase-explorer
Explore and understand the Empathy Ledger codebase architecture, data flows, database schema, services, and how components connect. Use when you need to understand where things are, how data flows, or how different parts of the system relate to each other.