Code Explore

---
name: code-explore
description: "Pure Claude code investigation. Use when: tracing execution paths, understanding architecture, diagnosing issues. Not for: dual-perspective review (use code-investigate), code review (use codex-code-review). Output: analysis report with findings."
allowed-tools: Read, Grep, Glob, Bash(ls:*), Bash(find:*)
context: fork
---

# Code Explore Skill

## Trigger

- Keywords: code explore, code investigation, research code, trace code, feature understanding, quick investigation, code exploration

## When to Use

- Quickly understand how a feature works
- Trace execution paths / data flow
- Diagnose problem root causes
- No dual confirmation needed (no Codex cross-validation)

## When NOT to Use

| Scenario                | Alternative                           |
| ----------------------- | ------------------------------------- |
| Need dual confirmation  | `/code-investigate` (Claude + Codex)  |
| Git history tracking    | `/git-investigate`                    |
| System verification     | `/feature-verify`                     |
| Code review             | `/codex-review-fast`                  |

## Workflow

```
┌──────────────────────────────────────────────────────────┐
│ Phase 1: Locate Entry Point                                │
├──────────────────────────────────────────────────────────┤
│ 1. Grep keywords -> find related files                     │
│ 2. Identify entry points (Controller / Service / Provider) │
│ 3. Build file list                                         │
└──────────────────────────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────┐
│ Phase 2: Trace Path                                        │
├──────────────────────────────────────────────────────────┤
│ 1. Start from entry point, Read                            │
│ 2. Identify dependencies -> continue tracing               │
│ 3. Map call chain (A -> B -> C)                            │
└──────────────────────────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────┐
│ Phase 3: Understand Logic                                  │
├──────────────────────────────────────────────────────────┤
│ 1. What is the core logic?                                 │
│ 2. How does data flow?                                     │
│ 3. Error handling mechanisms?                              │
│ 4. Key decision points?                                    │
└──────────────────────────────────────────────────────────┘
                          ↓
┌──────────────────────────────────────────────────────────┐
│ Phase 4: Output Report                                     │
├──────────────────────────────────────────────────────────┤
│ 1. Architecture overview (diagram / table)                 │
│ 2. Key files list                                          │
│ 3. Execution flow                                          │
│ 4. Findings / notes                                        │
└──────────────────────────────────────────────────────────┘
```

## Search Strategy

| Target          | Strategy                                                 |
| --------------- | -------------------------------------------------------- |
| Feature entry   | `Grep "export class.*Controller"` / `Grep "@Get\|@Post"` |
| Service layer   | `Grep "export class.*Service"`                           |
| Provider layer  | `Glob "src/provider/**/*.ts"`                            |
| Configuration   | `Read {CONFIG_FILE}`                                     |
| Data models     | `Glob "src/model/**/*.ts"`                               |

## Output Format

```markdown
## Investigation Report: {Topic}

### Architecture Overview

{ASCII or Mermaid diagram}

### Key Files

| File              | Responsibility |
| ----------------- | -------------- |
| `path/to/file.ts` | Description   |

### Execution Flow

1. {Step 1}
2. {Step 2}
3. ...

### Data Flow

{Describe how data flows}

### Findings

- {Important finding 1}
- {Important finding 2}

### Notes

- {Potential issue / edge case}
```

## Verification

- [ ] Entry points identified and listed
- [ ] Execution flow traced end-to-end
- [ ] Key files table includes all relevant files
- [ ] Findings section has actionable insights

## References

- `references/search-patterns.md` — Common search patterns for codebase exploration (read when building search strategy)

## Examples

### Feature Understanding

```
Input: Investigate how user data queries work
Phase 1: Grep "balance" -> find UserService, UserController
Phase 2: Controller -> Service -> Provider call chain
Phase 3: Understand query + cache mechanism
Phase 4: Output report + flow diagram
```

### Problem Diagnosis

```
Input: Why does this API sometimes return empty?
Phase 1: Grep "getData" + "cache" -> related files
Phase 2: Trace data retrieval path
Phase 3: Identify fallback logic + timeout handling
Phase 4: List possible causes + recommendations
```

### Architecture Understanding

```
Input: What is the overall architecture of the user module?
Phase 1: Glob "src/**/*user*" -> list all related files
Phase 2: Identify layer relationships (Controller -> Service -> Provider)
Phase 3: Understand each layer's responsibilities
Phase 4: Output architecture diagram + module description
```

## Difference from code-investigate

| Dimension    | code-explore           | code-investigate       |
| ------------ | ---------------------- | ---------------------- |
| Speed        | Fast (single view)     | Slow (dual view)       |
| Confirmation | Single perspective     | Cross-validation       |
| Tools        | Pure Claude            | Claude + Codex         |
| Use case     | Quick investigation    | Important decisions    |