Agent skill

explore-area

Orient on a new codebase area using get_context for token-budgeted exploration. Use when the user asks "what does this module do", "explain this part", or wants to understand an unfamiliar area before making changes.

View SKILL.md on GitHub Repository
Stars 3
Forks 1

Install this agent skill to your Project

npx add-skill https://github.com/anortham/julie/tree/main/.claude/skills/explore-area

SKILL.md

Explore Area

Orient on an unfamiliar area of the codebase using Julie's get_context tool. This is the recommended starting point before any modification task — understand the area first, then dive in.

Process

Step 1: Get Token-Budgeted Context

get_context(query="<area, concept, or module name>")

This returns:

  • Pivots: The most relevant symbols with full code bodies
  • Neighbors: Connected symbols with signatures only
  • File map: Which files contain which symbols

The output is automatically token-budgeted — few results get deep context, many results get broad overview.

Step 2: Identify Key Symbols

From the pivots, identify:

  • Entry points: Public functions/methods that external code calls (high centrality score)
  • Core types: Structs, enums, traits that define the area's data model
  • Utilities: Private helpers that support the entry points

Centrality scores in the output indicate how well-connected each symbol is — high-centrality symbols are the important ones.

Step 3: Drill Into Key Symbols (Optional)

For pivots that need more context (e.g., you need to see callers/callees):

deep_dive(symbol="<key_symbol>", depth="overview")

Use context_file if the symbol name is ambiguous:

deep_dive(symbol="<symbol>", depth="overview", context_file="<partial_path>")

Step 4: Check File Structure (Optional)

For files with many symbols that weren't fully covered by get_context:

get_symbols(file_path="<file>", mode="structure", max_depth=1)

This shows the full outline without reading the file contents.

Step 5: Report

Area: <concept/module>

Key Entry Points:
  - function_a (src/module.rs:45) — centrality: high
    Purpose: <what it does>
  - function_b (src/module.rs:120) — centrality: medium
    Purpose: <what it does>

Core Types:
  - StructA (src/types.rs:10) — <what it represents>
  - TraitB (src/traits.rs:5) — <what it defines>

File Map:
  src/module.rs — main implementation (function_a, function_b, helpers)
  src/types.rs — data types (StructA, EnumC)
  src/traits.rs — trait definitions (TraitB)

Dependency Flow:
  External callers → function_a → helper_1 → database queries
                   → function_b → TraitB implementations

Suggested Starting Point:
  <which file/function to read first for this task>

Tips

  • Use format: "readable" for human-friendly output with section separators and richer formatting: 
    get_context(query="...", format="readable")
    The default format is compact (optimized for AI agent consumption).
  • Use max_tokens to control budget if the default is too much or too little: 
    get_context(query="...", max_tokens=1000)
  • Filter by language or file pattern to narrow scope: 
    get_context(query="...", language="rust", file_pattern="src/tools/**")
  • Reference workspaces: Pass workspace: "<workspace_id>" to explore a non-primary workspace

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

anortham/julie

logic-flow

Explain a function's logic step-by-step by analyzing its implementation and call graph. Use when the user asks "how does this work", "walk me through this", or wants to understand control flow and decision points.

3 1
Explore
anortham/julie

metrics

Show Julie operational metrics -- session stats, tool usage, context efficiency, and historical trends. Use when the user asks about Julie's performance, how it's doing, how much context was saved, or wants a metrics/stats report.

3 1
Explore
anortham/julie

architecture

Generate an architecture overview — key entry points, module map, dependency flow, and suggested reading order. Use when the user is new to a codebase, asks "how does this work?", wants an architecture overview, or needs onboarding documentation.

3 1
Explore
anortham/julie

dependency-graph

Show module dependencies by analyzing imports, exports, and cross-references. Use when the user asks what a file imports, what depends on a module, or wants to see dependency structure.

3 1
Explore
anortham/julie

search-debug

Diagnose why a search returns unexpected results — analyze scoring factors, tokenization, and index health for dogfooding Julie's search quality. Use when a Julie search misses an expected symbol, returns wrong results, ranks something surprisingly low, or when investigating search quality issues during development.

3 1
Explore
anortham/julie

impact-analysis

3 1
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results