code-explore
/code-explore
Prowadzi śledztwo w kodzie samym Claude: śledzi ścieżki wykonania, wyjaśnia architekturę i diagnozuje problemy, a wynikiem jest raport z ustaleniami.
- Autor
- sd0xdev ↗
- Repozytorium
- sd0x-harness ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 08.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 2
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 08.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Prowadzi śledztwo w kodzie samym Claude: śledzi ścieżki wykonania, wyjaśnia architekturę i diagnozuje problemy, a wynikiem jest raport z ustaleniami.
Oryginalny opis (EN)
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.
Jak działa
- Trigger
- When to Use
- When NOT to Use
- Workflow
- Search Strategy
- Output Format
- Verification
- References
- Examples
- Difference from code-investigate
Podgląd SKILL.md
---
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 |
Pliki w paczce (2)
- SKILL.md 7 KB
- references/search-patterns.md 2 KB
Wersje
W bazie nie ma innych skilli o nazwie code-explore.
Migawka bazy z 13.11.2026 · wersja paczki dcf125f9f819 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100deep-explore
Koordynuje wielofalową, równoległą eksplorację kodu przy badaniach dużych baz i złożonych systemów, a wynikiem jest zbiorczy raport z oceną kompletności. - 100feature-dev
Prowadzi pętlę rozwoju funkcji, od implementacji i pisania kodu po testy i bramkę przeglądu, z wynikiem w postaci funkcji, testów i przeglądu. - 100tracer
Śledzi ścieżki wykonania, mapuje zależności, śledzi przepływ danych i łańcuchy wywołań w nieznanym kodzie oraz podpowiada, które pliki czytać dalej. - 100codex-review
Uruchamia przegląd kodu w Codex z niezależnym podwójnym sprawdzeniem przez Claude. - 84review-code
Recenzuje zmiany w kodzie pod kątem jakości, bezpieczeństwa i wydajności, w tym architektury i stylu, i ocenia, czy PR jest gotowy. - 100review
Przegląda niezatwierdzone zmiany, commit lub gałąź modelem innego dostawcy: Codex z Claude Code albo Claude Code z Codex.