Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

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.

Repozytorium
sd0x-harness ↗
Licencja
MIT
Ostatnia zmiana repozytorium
08.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 08.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. Trigger
  2. When to Use
  3. When NOT to Use
  4. Workflow
  5. Search Strategy
  6. Output Format
  7. Verification
  8. References
  9. Examples
  10. Difference from code-investigate
Sekcje z nagłówków SKILL.md, w oryginale · 158 linii, 612 słów
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.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.