Agent Skills: Explore command

Explore command

Read-only codebase orientation. Emit architecture, pattern, tooling, and dependency summaries for a repo-local task.

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.
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

• Grepping/globbing before dispatching Explore agents on multi-file tasks; dispatch first
• Bypassing token-efficient flags; use 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)