From sd0x-dev-flow
Investigates code by tracing execution paths, mapping data flow, and diagnosing root causes. Outputs an analysis report with architecture overview and findings.
How this skill is triggered — by the user, by Claude, or both
Slash command
/sd0x-dev-flow:code-exploreThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
- Keywords: code explore, code investigation, research code, trace code, feature understanding, quick investigation, code exploration
| Scenario | Alternative |
|---|---|
| Need dual confirmation | /code-investigate (Claude + Codex) |
| Git history tracking | /git-investigate |
| System verification | /feature-verify |
| Code review | /codex-review-fast |
┌──────────────────────────────────────────────────────────┐
│ 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 │
└──────────────────────────────────────────────────────────┘
| 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" |
## 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}
references/search-patterns.md — Common search patterns for codebase exploration (read when building search strategy)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
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
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
| 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 |
npx claudepluginhub sd0xdev/sd0x-dev-flow --plugin sd0x-dev-flowExplains, traces, audits, or explores code in read-only mode without modifying it. Answers questions like 'how does X work' or 'where is Y called' with evidence.
Traces actual code paths in codebases to analyze architecture, data flows, integrations, patterns, and provide recommendations across 5 evidence-based iterations. Use for deep 'how does X work' queries or complex system reviews.
Explores codebase areas: maps files, traces data flows, identifies patterns and dependencies. For 'how does X work', architecture queries, or pre-change analysis.