Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

bug-hunt

/bug-hunt

Proaktywnie poszukuje ukrytych defektów w funkcji lub module przez czytanie źródeł i śledzenie przepływu danych, zanim błędy trafią do produkcji.

Repozytorium
claude-kit ↗
Licencja
MIT
Ostatnia zmiana repozytorium
07.09.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 07.09.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

Proaktywnie poszukuje ukrytych defektów w funkcji lub module przez czytanie źródeł i śledzenie przepływu danych, zanim błędy trafią do produkcji.

Oryginalny opis (EN)

Proactively hunt latent defects across a feature/module by reading source and tracing data flow. Use to find bugs before they ship. Distinct from debugging a known failure or reviewing a diff.

Jak działa

  1. Overview
  2. When to Use
  3. How It Differs
  4. The Hunt
  5. Honesty & Evidence
  6. Red Flags
  7. Verification
  8. See Also
Sekcje z nagłówków SKILL.md, w oryginale · 166 linii, 1 208 słów
Podgląd SKILL.md
---
name: bug-hunt
description: Proactively hunt latent defects across a feature/module by reading source and tracing data flow. Use to find bugs before they ship. Distinct from debugging a known failure or reviewing a diff.
---

# Bug Hunt

## Overview

A **proactive, source-driven** search for bugs that have not surfaced yet. You are not fixing a
reported failure and you are not checking a feature against a spec — you are reading the
implementation as written, building a mental model of how data moves through it, and asking at every
step "what input, ordering, or state makes this go wrong?"

The output is a list of concrete, evidence-backed findings, each rated on the project's standard
severity model and each pointing at an exact location with a way to reproduce it.

This is the discovery counterpart to the kit's other quality skills. Use it when you want to find
*unknown* problems in code that currently "works."

## When to Use

- Before shipping a feature, to surface defects the happy-path tests never exercise.
- After a feature is built but before (or alongside) the formal review gates.
- When inheriting unfamiliar code and you need to know where it is fragile.
- When a class of bug keeps recurring and you want to sweep a module for siblings.

**When NOT to use:**
- A test is failing or an error is in front of you → `debugging-and-error-recovery` (reactive,
  single root cause).
- You are reviewing a specific change/diff → `code-review-and-quality` (change-scoped).
- You need to verify behavior against acceptance criteria on a running app → the `tester` /
  `senior-tester` lane.

## How It Differs

| Skill / agent | Trigger | Scope |
|---|---|---|
| **bug-hunt** (this) | proactive, nothing is broken yet | a whole feature/module, source-only |
| debugging-and-error-recovery | a known failure exists | one root cause |
| code-review-and-quality | a diff/PR is up | the changed lines |
| senior-tester / tester | acceptance criteria + running app | spec-bound verification |
| auditor | a runtime surface to probe | live behavior, not source reading |

## The Hunt

### Step 1 — Map the feature

Read the source for the target feature end to end before judging any single line. Produce a short
map:

- **Entry points** — the functions/handlers/routes/components a user or caller can reach.
- **Data flow** — how a value travels from entry point → transformation → storage/output, and back.
- **Boundaries** — every place the feature crosses a trust or process boundary (user input, network,
  storage, queue/worker, another service, the rendering layer).
- **State** — what is mutated, cached, shared, or persisted, and who else touches it.

You cannot find data-shape or ordering bugs without this map. Spend the time.

### Step 2 — Sweep the scenario taxonomy

For every entry point and boundary on the map, walk this fixed checklist. It is deliberately broad —
the point is coverage, so do not stop at the first finding in a category.

```
1. Input edge cases
   ├── empty / null / missing / default-only payloads
   ├── boundary values (0, negative, max, off-by-one, very large)
   ├── wrong type / malformed / unexpected extra fields
   └── unicode, whitespace, embedded quotes/markup, injection-shaped strings

2. An error state per failure point
   └── for EACH external call, parse, or computation that can fail:
       is the failure caught, surfaced, and recovered — or silently swallowed?
       (a bare catch that hides the error is itself a finding)

3. State management
   ├── stale reads / write-after-read / lost updates
   ├── cache invalidation gaps and shared-mutable state
   └── leaked state between requests, sessions, or test cases

4. Race / concurrency / ordering
   ├── two callers hit the same resource at once
   ├── async results arrive out of order or after teardown
   └── retries/duplicate delivery without idempotency

5. Rendering / display / output
   ├── empty, loading, error, and partial states actually handled
   ├── formatting of numbers/dates/currency/timezones
   └── pagination, truncation, and overflow

6. Authorization & scoping
   ├── can a caller act on data they do not own / outside their tenant?
   ├── missing ownership/permission check on a mutating path
   └── identifiers from the client trusted without re-checking access
```

For each suspicion, **confirm it in the source** before recording it. A hunch is not a finding;
a line of code that demonstrably mishandles the case is.

### Step 3 — Record each finding

One entry per finding, in severity order:

```
### [Severity] Short title
- **Where:** path/to/file.ext:LINE  (the exact site, not "somewhere in X")
- **What:** the incorrect behavior, stated concretely
- **Repro:** the input / ordering / state that triggers it
- **Why:** the root cause in the code (quote the offending lines)
- **Impact:** what a user or the system experiences
- **Fix direction:** the smallest correct change (a pointer, not a full patch)
```

Use the project's standard severity model — **Critical / High / Medium / Low / Cosmetic** (see
`.claude/rules/quality-gates.md`); do not invent a parallel scale. Calibrate by blast radius and
likelihood:

- **Critical** — data loss/corruption, auth bypass, or a crash on a common path.
- **High** — wrong result or unhandled failure on a realistic input.
- **Medium** — edge case that misbehaves; degraded but recoverable.
- **Low / Cosmetic** — minor display or robustness gap.

### Step 4 — Systemic pass

After the per-site sweep, step back: do the individual findings rhyme? A single missing null check
is a bug; the *same* missing check at five sites is a missing pattern (a shared guard, a validation
boundary, an error-handling convention). Record the pattern once, list its instances, and recommend
the systemic fix — it is worth more than the five line-fixes.

### Step 5 — Summarize

Close with:

- A count by severity.
- The **top 3 things to fix first**, chosen by impact × likelihood (not by how many there are).
- Any area you could not fully assess (so the gap is visible, not silently dropped — see
  `.claude/rules/quality-gates.md` §2.5 on evidence).

## Honesty & Evidence

- Every finding cites a real location and a real reproduction. No speculative "this might break."
- If you read a path and it is correct, say so — do not pad the count.
- Report what you did **not** cover. A bounded hunt that names its blind spots beats one that
  implies total coverage. See `.claude/rules/agent-guardrails.md` §2.

## Red Flags

- Findings with no `path:line` or no reproduction.
- Reporting style/lint nits as bugs (that is the linter's job).
- Stopping at the first finding per category instead of sweeping.
- Inflating severity to look thorough.
- Re-running this on a diff instead of using `code-review-and-quality`.

## Verification

- [ ] The feature map (entry points, data flow, boundaries, state) was written before judging lines.
- [ ] Every taxonomy category was swept for every entry point/boundary.
- [ ] Each finding has location + repro + root cause quoted from source.
- [ ] Findings are rated on the Critical/High/Medium/Low/Cosmetic model.
- [ ] A systemic pass grouped recurring findings into pattern-level fixes.
- [ ] The summary names the top 3 fixes and any uncovered area.

## See Also

- `debugging-and-error-recovery` — once a hunt finding (or any failure) needs root-causing and fixing.
- `code-review-and-quality` — change-scoped review of a specific diff.
- `senior-tester` / `tester` agents — spec-bound verification against a running app.
- `auditor` agent — runtime probing of a live surface.
Pliki w paczce (2)
  • SKILL.md 8 KB
  • references/alld-048-race-conditions-and-critical-sections.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · ajyadav013/claude-kit100MIT
j0hanz/j0hanz-marketplace100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
artk0de/tearags-mcp100MIT
yeaight7/agent-powerups100Apache-2.0
ajyadav013/claude-kit100MIT
Er2oneousbit/claude-code-game-kit86MIT

Migawka bazy z 13.11.2026 · wersja paczki df5c4b7e121e (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

  • 100bug-hunt-review
    Recenzuje kod lub diff pod kątem realnych defektów (błędne wyniki, awarie, utrata danych, luki bezpieczeństwa) i opisuje każdy konkretnym scenariuszem awarii, pomijając uwagi o stylu.
  • 100bug-analyzer
    Analizuje przyczyny źródłowe błędu zgłoszonego w Sentry, zgłoszeniu Jira lub opisie błędu oraz aktywnie poszukuje ukrytych błędów w audytach kodu.
  • 100bug-fix
    Pomaga naprawiać błędy zgodnie ze standardami projektu: debugowanie, rozwiązywanie zgłoszonych problemów i usuwanie defektów w kodzie.
  • 95bughunt
    Przeszukuje kod w czternastu wymiarach w poszukiwaniu błędów, odrzuca fałszywe alarmy i tworzy raport z ważnością.
  • 100bug-hunter
    Skanuje kod źródłowy pod kątem błędów, antywzorców i code smelli albo prowadzi polowanie na błędy z dowodem: znajduje, udowadnia, naprawia i weryfikuje jeden realny defekt.
  • 100hunt
    Znajduje prawdziwe błędy w kodzie źródłowym, a w rundzie /bughunt dowodzi, naprawia i weryfikuje jeden z nich, także przy audycie plików, wyciekach, wyścigach i nieobsłużonych błędach.

Uwagi i zgłoszenia

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