Skip to content
Skills Library
Programming · Research

explore

/explore

Read-only codebase exploration: discovery, structural reading, and emission of architecture/pattern/tooling/dependency summaries. Use to understand existing code, map files, trace function flow, locate symbols, or build pre-implementation context. Uses 1/3/5 Explore-agent escalation scaled to scope. Trigger on \"explore\", \"find where X is\", \"how does X work in the code\", \"map the codebase\", \"what files handle Y\", or any architecture/pattern/tooling/dependency context request on a local repo — even without naming /explore.

Licence
Apache-2.0
Last repository change
08.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 08.07.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Read-only codebase exploration: discovery, structural reading, and emission of architecture/pattern/tooling/dependency summaries. Use to understand existing code, map files, trace function flow, locate symbols, or build pre-implementation context. Uses 1/3/5 Explore-agent escalation scaled to scope. Trigger on \"explore\", \"find where X is\", \"how does X work in the code\", \"map the codebase\", \"what files handle Y\", or any architecture/pattern/tooling/dependency context request on a local repo — even without naming /explore.

Triggers from the description

explore\find where X is\how does X work in the code\map the codebase\what files handle Y\
Original author description

Read-only codebase exploration: discovery, structural reading, and emission of architecture/pattern/tooling/dependency summaries. Use to understand existing code, map files, trace function flow, locate symbols, or build pre-implementation context. Uses 1/3/5 Explore-agent escalation scaled to scope. Trigger on \"explore\", \"find where X is\", \"how does X work in the code\", \"map the codebase\", \"what files handle Y\", or any architecture/pattern/tooling/dependency context request on a local repo — even without naming /explore.

How it works

  1. When to Apply / NOT
  2. Process
  3. Required Output
  4. Tool Restrictions
  5. Anti-Patterns
Original SKILL.md headings · 104 lines, 551 words
SKILL.md preview
---
name: explore
description: "Read-only codebase exploration: discovery, structural reading, and emission of architecture/pattern/tooling/dependency summaries. Use to understand existing code, map files, trace function flow, locate symbols, or build pre-implementation context. Uses 1/3/5 Explore-agent escalation scaled to scope. Trigger on \"explore\", \"find where X is\", \"how does X work in the code\", \"map the codebase\", \"what files handle Y\", or any architecture/pattern/tooling/dependency context request on a local repo — even without naming /explore."
---

# Explore Command

Read-only codebase orientation. Emit architecture, pattern, tooling, and dependency summaries for a repo-local task. Do NOT write, edit, or commit files.

## When to Apply / NOT

**Apply:**
- Pre-implementation codebase orientation (feature, fix, refactor)
- File and symbol mapping — "where is X defined", "what uses Y"
- Architectural surveys — module boundaries, control flow, coupling
- Dependency tracing — import graphs, transitive deps, config files

**NOT apply:**
- External library docs, SDK APIs, or framework behavior — use a doc-retrieval workflow instead
- User wants a packed repo file as a deliverable artifact
- Implementation, editing, or committing anything

## Process

1. **Scope** — parse the task. Identify files/dirs/concerns. State scope explicitly before dispatching.
2. **Dispatch decision** — for multi-file or uncertain tasks: dispatch Explore agent(s) instead of reading directly. Escalation: 1 agent for single-concern known scope; 3 agents for multiple concerns or unknown scope; 5 agents for cross-module or architectural survey. Auto-skip (direct reads allowed) only for single file under 50 LOC.
3. **Discovery** — token-efficient flags mandatory:
   - File discovery: `fd -e <ext> --max-results 50`
   - Symbol search: `ast-grep run -p 'PATTERN' -l <lang> -C 1` or `git --no-pager grep -n -C 2 'pattern'`
   - Content preview: `bat -P -p -n -r START:END file` or `Read -offset -limit`
   - Directory structure: `eza --tree --level=2`
4. **Synthesis** — emit all Required Output sections. No file writes.
5. **Heavy-codebase escape hatch** — scope > 50 files: use a codebase-packing tool if available as an internal analysis aid (not handed to the user as output); search the packed output for targeted extraction.

## Required Output

Emit all 8 sections. Omit a section only when genuinely not applicable; state why.

### Task Understanding

Brief restatement of the task and identified scope boundaries.

### Architecture Context

```
[Module/Layer Name]
- path/to/file.ts:L10-50 — [Purpose] — [Relevance]
- path/to/interface.ts — [Purpose] — [Relevance]
```

### Pattern Context

```
[Pattern Category]
- path/to/reference.ts — [Pattern description] — [How to apply]
```

### Tooling Context

```
- Build: [command] — [when to run]
- Test: [command] — [scope/coverage]
- Lint: [command] — [config location]
```

### Dependency Map

```
Internal:
- module-a -> module-b (reason)

External:
- library-name@version — [usage context]
```

### Critical Files Summary

Prioritized list of files most relevant to the task:

| Priority | File | Purpose | Action Hint |
|----------|------|---------|-------------|
| P0 | path/to/core.ts | Core logic | Modify |
| P1 | path/to/types.ts | Type definitions | Extend |
| P2 | path/to/utils.ts | Helpers | Reference |

### Constraints & Considerations

- [Constraint 1]: [Impact on implementation]
- [Constraint 2]: [Impact on implementation]

### Recommended Next Steps

1. [First action with specific file reference]
2. [Second action with specific file reference]

## Tool Restrictions

**Allowed (read-only):** `eza`, `fd`, `ast-grep` (find-only), `git grep`, `rg`, `bat`, `tokei`, `Read`, `codebase_search`, and any available codebase-analysis or codebase-packing MCP tooling

**Banned:** `Edit`, `Write`, `mcp__edit__edit_file`, `git commit`, any state-mutating bash command

## Anti-Patterns

- Reading whole files when line ranges suffice — use `bat -r` or `Read -offset -limit`
- Grepping/globbing before dispatching Explore agents on multi-file tasks — dispatch first
- Bypassing token-efficient flags — `bat -P -p -n`, `rg -l`, `fd --max-results 50`
- Re-entering a router or orchestrator skill from within this leaf skill — forbidden (recursion guard)

Versions

RepositoryScoreLicence
This page · OutlineDriven/odin-codex-plugin100Apache-2.0
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
rapiddweller/archkeel100MIT
zimoliao/scholaraio100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT

Database snapshot: 13.11.2026 · package version 6543e3db4736 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95codebase-explore
    Read-only codebase exploration and analysis. Use when the user asks "analyze codebase", "explore code", "what does this project do", "find files related to", "understand architecture", or needs to research the codebase before making changes. Cannot modify any files.
  • 100kastell-research
    Read-only Kastell codebase exploration. Use when tracing a bug across files, mapping callsites before refactoring, or exploring unfamiliar subsystems. Runs in isolated context with Explore agent.
  • 90explore-codebase
    Explore codebase files, patterns, and structure for a given topic. USE WHEN gathering implementation context before planning or executing tasks, when asked to research the codebase, or when a planning agent needs a Sub-Agent A (Codebase Research). Returns a Codebase Research…
  • 84explore-codebase
    Explore and understand how the codebase works. Use when user asks "how does the authentication work", "where is the API endpoint defined", "show me how data flows through the system", "explain this module's architecture", "trace the request from controller to database", or "I…
  • 100semantic-codebase-intelligence
    Deep structural analysis of a codebase—dependency mapping, architecture boundary detection, coupling/cohesion scoring, and dead code discovery. Use when asked to \"analyze codebase structure\", \"map dependencies\", \"find dead code\", \"architecture analysis\", \"coupling…
  • 81ork-explore
    Map an unfamiliar codebase, feature, architecture, data flow, or operational path with file-backed evidence. Use when a request asks how a system works, where behavior lives, what changed, which dependencies matter, or for onboarding before a change. Do not use to implement or fix the code.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.