explore

/explore - Codebase Exploration

Spin up parallel subagents to thoroughly explore the current project and generate a comprehensive understanding.

---

When To Use

• Starting work on an unfamiliar codebase
• Before creating a PRD for a new feature
• Understanding how existing features work
• Auditing dependencies or security
• Onboarding to a project

---

Usage

/explore

Or with a specific focus:

/explore "authentication system"
/explore "API endpoints"
/explore "database models"

---

Exploration Modes

When the user runs /explore, ask what they want to explore:

What would you like to explore?

1. Full codebase overview
   1.1. Complete analysis (structure, patterns, architecture, dependencies)
   1.2. Quick overview (just structure and key files)

2. Specific focus area
   2.1. How does [feature] work?
   2.2. Where is [functionality] implemented?
   2.3. What calls/uses [component]?

3. Technical audit
   3.1. Dependencies and versions
   3.2. Security patterns
   3.3. Test coverage
   3.4. Code quality patterns

---

Phase 1: Launch Parallel Exploration Agents

For a full codebase overview, launch these agents in parallel:

Agent 1: Structure Explorer

Explore the project structure:
- Directory layout and organization
- Key directories and their purposes
- Entry points (main files, index files)
- Configuration files
- Build/deploy files

Output a structured summary of the project layout.

Agent 2: Pattern Explorer

Identify coding patterns in this codebase:
- Naming conventions (files, functions, variables)
- Code organization patterns (MVC, services, etc.)
- Error handling patterns
- Logging patterns
- Common utilities and helpers

Output the key patterns a developer should follow.

Agent 3: Dependency Explorer

Analyze project dependencies:
- Package manager (npm, pip, cargo, etc.)
- Key dependencies and their purposes
- Dev dependencies
- Dependency versions (any outdated?)
- Internal module dependencies

Output a dependency overview.

Agent 4: Architecture Explorer

Understand the architecture:
- Application type (web app, API, CLI, library, etc.)
- Tech stack (languages, frameworks, databases)
- Data flow (how data moves through the system)
- External integrations (APIs, services)
- Key abstractions and interfaces

Output an architecture summary.

Launching Agents

Use the Task tool with subagent_type: "Explore" for each:

Launch all 4 agents in parallel using a single message with multiple Task tool calls.

Each agent should:
- Focus on its specific area
- Be thorough but concise
- Output findings in markdown format
- Complete within one context window

---

Phase 2: Aggregate Results

After all agents complete, combine their findings into a single report:

Report Structure

# Codebase Exploration Report

**Project:** [detected project name]
**Generated:** [timestamp]
**Explored by:** Aeon Loop /explore

---

## Overview

[One paragraph summary of what this project is]

---

## Project Structure

[Output from Structure Explorer]

### Key Directories
| Directory | Purpose |
|-----------|---------|
| src/ | ... |
| ... | ... |

### Entry Points
- ...

---

## Architecture

[Output from Architecture Explorer]

### Tech Stack
- **Language:** ...
- **Framework:** ...
- **Database:** ...

### Data Flow
[Diagram or description]

---

## Patterns & Conventions

[Output from Pattern Explorer]

### Naming Conventions
- Files: ...
- Functions: ...
- Variables: ...

### Code Patterns
- ...

---

## Dependencies

[Output from Dependency Explorer]

### Key Dependencies
| Package | Version | Purpose |
|---------|---------|---------|
| ... | ... | ... |

### Potential Issues
- [outdated deps, security concerns, etc.]

---

## Key Files Reference

| File | Purpose |
|------|---------|
| ... | ... |

---

## Recommendations

[Based on exploration, any suggestions for the user]

---

## Next Steps

- To build a new feature: `/aeon-flux`
- To create just a PRD: `/prd`
- To start autonomous work: `/loop "task" --done "COMPLETE"`

---

Phase 3: Save Report

Save the aggregated report:

mkdir -p .planning/exploration

Save to .planning/exploration/report.md

If exploring a specific area, save to .planning/exploration/[area-slug].md

---

Focused Exploration

When user wants to explore something specific:

"How does X work?"

Launch a single focused agent:

Trace how [X] works in this codebase:
1. Find the entry point for [X]
2. Follow the code path
3. Identify key functions/methods involved
4. Note any external dependencies
5. Document the flow

Output a clear explanation with file:line references.

"Where is X implemented?"

Find where [X] is implemented:
1. Search for relevant files
2. Identify the main implementation
3. Find related files (tests, types, etc.)
4. Note any configuration

Output file paths with brief descriptions.

"What calls/uses X?"

Find all usages of [X]:
1. Search for imports/requires
2. Find function calls
3. Identify dependent code
4. Map the dependency graph

Output a list of files and how they use [X].

---

Example Session

User: /explore

Claude: What would you like to explore?

1. Full codebase overview
   1.1. Complete analysis
   1.2. Quick overview

2. Specific focus area
   2.1. How does [feature] work?
   2.2. Where is [functionality] implemented?

3. Technical audit
   3.1. Dependencies
   3.2. Security patterns

User: 1.1

Claude: Launching exploration agents...

[Launches 4 parallel agents]

Agent 1 (Structure): Exploring project structure...
Agent 2 (Patterns): Identifying coding patterns...
Agent 3 (Dependencies): Analyzing dependencies...
Agent 4 (Architecture): Understanding architecture...

[Agents complete]

Claude: Here's what I found:

# Codebase Exploration Report
[Full report]

Saved to .planning/exploration/report.md

Would you like to:
- Dive deeper into any area?
- Start building with /aeon-flux?
- Create a PRD for a feature?

---

Integration with Aeon Flux

When /aeon-flux offers exploration first, it should:

1. Ask: "Would you like me to explore the codebase first?"
2. If yes: Run /explore with quick overview (1.2)
3. Use findings to inform PRD questions
4. Reference exploration report in planning

The exploration report becomes context for better PRD creation.

---

Output Files

.planning/
└── exploration/
    ├── report.md           # Full codebase report
    ├── auth-system.md      # Focused exploration
    └── api-endpoints.md    # Focused exploration

---

Checklist

Before completing exploration:

• Launched appropriate agents (parallel for full, single for focused)
• Aggregated all agent outputs
• Generated structured report
• Saved to .planning/exploration/
• Offered next steps to user