Explore - Internal Codebase Exploration

Meta-skill for exploring an internal codebase at varying depths. READ-ONLY workflow - no code changes.

Usage

/explore <depth> [options]

Question Flow (No Arguments)

If the user types just /explore with no or partial arguments, guide them through this question flow. Use AskUserQuestion for each phase.

Phase 0: Workflow Selection

question: "How would you like to explore?"
header: "Explore"
options:
  - label: "Help me choose (Recommended)"
    description: "I'll ask questions to pick the right exploration depth"
  - label: "Quick - fast overview"
    description: "Chain: tldr tree → tldr structure (~1 min)"
  - label: "Deep - comprehensive analysis"
    description: "Chain: onboard → tldr → research → document (~5 min)"
  - label: "Architecture - layers & dependencies"
    description: "Chain: tldr arch → call graph → layer mapping (~3 min)"

Mapping:

• "Help me choose" → Continue to Phase 1-4 questions
• "Quick" → Set depth=quick, skip to Phase 2 (scope)
• "Deep" → Set depth=deep, skip to Phase 2 (scope)
• "Architecture" → Set depth=architecture, skip to Phase 2 (scope)

If Answer is Unclear (via "Other"):

question: "I want to understand how deep you want to explore. Did you mean..."
header: "Clarify"
options:
  - label: "Help me choose"
    description: "Not sure - guide me through questions"
  - label: "Quick - fast overview"
    description: "Just want to see what's here"
  - label: "Deep - comprehensive analysis"
    description: "Need thorough understanding"
  - label: "Neither - let me explain differently"
    description: "I'll describe what I need"

Phase 1: Exploration Goal

question: "What are you trying to understand?"
header: "Goal"
options:
  - label: "Get oriented in the codebase"
    description: "Quick overview of structure"
  - label: "Understand how something works"
    description: "Deep dive into specific area"
  - label: "Map the architecture"
    description: "Layers, dependencies, patterns"
  - label: "Find where something is"
    description: "Locate specific code/functionality"

Mapping:

• "Get oriented" → quick depth
• "Understand how" → deep depth
• "Map architecture" → architecture depth
• "Find where" → quick with --focus

Phase 2: Scope

question: "What area should I focus on?"
header: "Focus"
options:
  - label: "Entire codebase"
    description: "Explore everything"
  - label: "Specific directory or module"
    description: "I'll specify the path"
  - label: "Specific concept/feature"
    description: "e.g., 'authentication', 'API routes'"

If "Specific directory" or "Specific concept" → ask follow-up for the path/keyword.

Phase 3: Output Format

question: "What should I produce?"
header: "Output"
options:
  - label: "Just tell me what you find"
    description: "Interactive summary in chat"
  - label: "Create a documentation file"
    description: "Write to thoughts/shared/docs/"
  - label: "Create handoff for implementation"
    description: "Prepare context for coding agent"

Mapping:

• "Documentation file" → --output doc
• "Handoff for implementation" → --output handoff

Phase 4: Entry Point (Architecture only)

If architecture depth selected:

question: "Where should I start the analysis?"
header: "Entry point"
options:
  - label: "Auto-detect (main, cli, app)"
    description: "Find common entry points"
  - label: "Specific function/file"
    description: "I'll specify the entry point"

Summary Before Execution

Based on your answers, I'll run:

**Depth:** deep
**Focus:** "authentication"
**Output:** handoff
**Path:** src/

Proceed? [Yes / Adjust settings]

Depths

Depth	Time	What it does
quick	~1 min	tldr-explorer only - fast structure overview
deep	~5 min	onboard + tldr-explorer + research-codebase + write doc
architecture	~3 min	tldr arch + call graph + layer mapping + circular dep detection

Options

Option	Description	Example
--focus "area"	Focus on specific area	--focus "auth", --focus "api"
--output handoff	Create handoff for next agent	--output handoff
--output doc	Create documentation file	--output doc
--entry "func"	Start from specific entry point	--entry "main", --entry "process_request"

Examples

# Quick structure overview
/explore quick

# Deep exploration focused on auth
/explore deep --focus "auth" --output doc

# Architecture analysis from specific entry
/explore architecture --entry "cli" --output handoff

# Quick focused exploration
/explore quick --focus "hooks"

Workflow Details

Quick Depth

Fast structure overview using tldr-explorer. Best for:

• Initial orientation
• Quick questions about structure
• Finding where things are

Steps:

1. Run tldr tree for file structure
2. Run tldr structure for codemaps
3. If --focus provided, run tldr search for targeted results
4. Return summary

Commands:

# 1. File tree
tldr tree ${PATH:-src/} --ext .py

# 2. Code structure
tldr structure ${PATH:-src/} --lang python

# 3. Focused search (if --focus provided)
tldr search "${FOCUS}" ${PATH:-src/}

Deep Depth

Comprehensive exploration with documentation output. Best for:

• First time in a codebase
• Preparing for major work
• Creating reference documentation

Steps:

1. Check if onboarded (look for .claude/cache/tldr/), if not run onboard
2. Run tldr-explorer for structure
3. Spawn research-codebase agent for patterns
4. Write findings to doc or handoff

Subprocess:

# 1. Onboard check
if [ ! -f .claude/cache/tldr/arch.json ]; then
    # Spawn onboard agent
fi

# 2. Structure analysis
tldr structure src/ --lang python
tldr calls src/

# 3. Research patterns (via scout agent)
Task: research-codebase → "Document existing patterns in ${FOCUS:-codebase}"

# 4. Write output
→ thoughts/shared/research/YYYY-MM-DD-explore-{focus}.md
→ OR thoughts/shared/handoffs/{session}/explore-{focus}.yaml

Architecture Depth

Architecture-focused analysis with layer detection. Best for:

• Understanding system boundaries
• Preparing for refactoring
• Identifying coupling issues

Steps:

1. Run tldr arch for layer detection
2. Run tldr calls for cross-file call graph
3. Analyze entry/middle/leaf layers
4. Detect circular dependencies
5. Map architectural boundaries

Commands:

# 1. Architecture detection
tldr arch ${PATH:-src/}
# Returns: entry_layer, middle_layer, leaf_layer, circular_deps

# 2. Call graph
tldr calls ${PATH:-src/}
# Returns: edges, nodes

# 3. Impact analysis from entry point (if --entry provided)
tldr impact ${ENTRY} ${PATH:-src/} --depth 3

Output Structure:

layers:
  entry: [routes.py, cli.py, main.py]  # Controllers/handlers
  middle: [services.py, auth.py]        # Business logic
  leaf: [utils.py, helpers.py]          # Utilities

call_graph:
  total_edges: 142
  hot_paths: [process_request → validate → authorize]

circular_deps:
  - [module_a, module_b]  # A imports B, B imports A

boundaries:
  - name: API layer
    files: [src/api/*
how to use explore
CursorClaude CodeClineCodexWindsurfGooseGitHub CopilotVS CodeGemini CLIKiloOpencodeKimi CLIRoo ClineAiderContinueZedBolt.newLovablev0Replit AgentSweepSmol DeveloperDevinCavemanAmpAntigravity
How to use explore on Cursor
AI-first code editor with Composer
1
Prerequisites
Before installing skills in Cursor, ensure your development environment meets these requirements:
›Cursor installed and configured on your development machine
›Node.js version 16.0+ with npm package manager (verify with node --version)
›Active project directory or workspace where you want to add explore
2
Execute installation command
Execute the skills CLI command in your project's root directory to begin installation:
$npx skills add https://github.com/parcadei/continuous-claude-v3 --skill explorecopy
The skills CLI fetches explore from GitHub repository parcadei/continuous-claude-v3 and configures it for Cursor.
3
Select Cursor when prompted
The CLI will show a list of available agents. Use arrow keys to navigate and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ── always included ────
│   • Amp
│   • Antigravity
│   • Cline
│   • Codex
│ ●Cursor(selected)
│   • Cursor
│   • Windsurf
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/explore
Reload or restart Cursor to activate explore. Access the skill through slash commands (e.g., /explore) or your agent's skill management interface.
⚠
Security & Verification Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your development environment. Always verify the publisher's identity, review recent commits, and test in isolated environments before production deployment.
Additional Resources
›View source code on GitHub›Skills CLI documentation›Learn more about Cursor›What are agent skills?