Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

find

/find

Szereguje usprawnienia w kodzie, wydajności, produkcie i konfiguracji Claude Code, z dowodami i rozmiarem S, M lub L, niczego nie edytując.

Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

84/ 100Klasa: dobry
Format9 / 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
13
Skrypty
4
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.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 sprawdzić przed instalacją
  • 4 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: evals/fixtures/disconnected-admin-export/src/admin/routes.js, evals/fixtures/disconnected-admin-export/src/db.js, evals/fixtures/disconnected-admin-export/src/flags.js, evals/fixtures/disconnected-admin-export/src/reports/csv-exporter.js

Co robi i kiedy

Szereguje usprawnienia w kodzie, wydajności, produkcie i konfiguracji Claude Code, z dowodami i rozmiarem S, M lub L, niczego nie edytując.

Wyzwalacze z opisu

instrument thiswhat should we improveimprovement sweepwhat could we improve in Xtech debt sweepwhere is the highest-value workwhat would move the needlerun an improvement scan

Argumenty

/find [target] [--small|--medium|--large] [--unattended] [repo-path]
Oryginalny opis (EN)

Rank improvements across code, performance, product, config, Claude Code setup, evidence-cited and sized S/M/L; unmeasured targets yield 'instrument this'. Never edits; unattended files work items. Use when: 'what should we improve', 'improvement sweep', 'what could we improve in X', 'tech debt sweep', 'where is the highest-value work', 'what would move the needle', 'run an improvement scan'. Skip: `architecture:improve`, `code-tidying:tidy`, `codebase-health:audit`, `review:fanout`, `work-items:scan-todos`.

Jak działa

  1. Repository context. Gather first
  2. Variables
  3. Purpose
  4. Prompt interpretation
  5. Scan dimensions
  6. Evidence ladder
  7. Evidence sources (tiered, presence-gated)
  8. Lane delegation as scan input
  9. Candidate output shape
  10. Interactive flow
Sekcje z nagłówków SKILL.md, w oryginale · 280 linii, 2 512 słów
Podgląd SKILL.md
---
description: "Rank improvements across code, performance, product, config, Claude Code setup, evidence-cited and sized S/M/L; unmeasured targets yield 'instrument this'. Never edits; unattended files work items. Use when: 'what should we improve', 'improvement sweep', 'what could we improve in X', 'tech debt sweep', 'where is the highest-value work', 'what would move the needle', 'run an improvement scan'. Skip: `architecture:improve`, `code-tidying:tidy`, `codebase-health:audit`, `review:fanout`, `work-items:scan-todos`."
argument-hint: "[target] [--small|--medium|--large] [--unattended] [repo-path]"
user-invocable: true
disable-model-invocation: false
metadata:
  workflow-stage: anytime
  summary: Rank evidence-cited improvement candidates across dimensions; execution goes to the pipeline
---

## Repository context. Gather first

Collect these with **individual** Bash calls, one command per call, never combined into a single
invocation:

- Current branch, `git branch --show-current`
- Recent commits, `git log --oneline -15`
- Working tree status (empty = clean), `git status --porcelain | head -10`
- Shallow repository, `git rev-parse --is-shallow-repository`

The pipe is the bound and belongs in the command. A read-time cap ("read only the first 10 entries")
bounds nothing: the Bash tool returns the command's complete output into context before there is
anything to decide about.

Treat a failure (not a repository, git unavailable) as an unknown value and carry on. A
worktree-isolated session refuses a compound command that contains git, which is why each call
above stays on its own. The dated record for that refusal, and for the pre-compute composition that
makes it bite, is the `source-control` plugin's
[worktree/reference/gather-block.md](https://raw.githubusercontent.com/melodic-software/claude-code-plugins/main/plugins/source-control/skills/worktree/reference/gather-block.md),
"The pre-compute block runs as one shell invocation".

## Variables

Arguments: `$ARGUMENTS`

## Purpose

This skill answers "what should we improve here, and how do we know?", the second half of that
question is its identity. Review evaluates a diff; planning designs already-chosen work; the
specialized finders each hunt one lens. This skill forms its own cross-dimension judgment about
what is worth improving in a target: code, product behavior, process surfaces, operational setup, and grounds every proposal in cited evidence, so ranking reflects measurement, not taste. It
discovers and deliberates only: execution always flows through the repo's normal pipeline
(interview → discovery → planning → implementation → verification).

## Prompt interpretation

Parse `$ARGUMENTS` and the invoking prompt for four independent narrowings; each defaults open:

- **Target scope.** Bare invocation scans the whole repo across every dimension below. A targeted
  ask, "improve <feature>", "improve <path>", "improve <concept>", narrows the scan: map the
  named feature/path/concept to its concrete surfaces (files, workflows, config, ops touchpoints)
  before gathering evidence, and gather evidence for those surfaces only. A concept with no
  resolvable surface is itself a finding (likely instrument-first, below).
- **Size band.** `--small` / `--medium` / `--large` (or equivalent prose: "quick wins only", "big
  swings") restricts candidates to that size band. Default: all sizes, ranked together.
- **Repo as parameter.** One repo per invocation. An explicit repo path in the arguments makes that
  checkout the target; otherwise the current repo is. When the target is not the session's working
  directory, resolve its root once (`git -C <repo-path> rev-parse --show-toplevel`) and anchor
  EVERY probe to it. `git -C <root>` for every git command here and in the `context/` recipes,
  and file reads under that root, so the evidence never silently comes from the invoking repo.
  The branch/log calls above describe the session's cwd, not the target; re-run them
  with `-C <root>` in that case. Fleet-wide sweeps are out of scope. Compose with
  `repo-fleet-hygiene` externally, one invocation per repo.
- **Mode.** Interactive is the default. Unattended is entered ONLY when the caller declares it (see
  Unattended mode), never inferred from context.

## Scan dimensions

The scan walks this inventory explicitly, so it cannot silently collapse to code-only. For each
dimension, gather whatever evidence its tier sources yield, then propose candidates:

| Dimension | Examples of what to look at |
|---|---|
| Code / architecture | Churn×complexity hotspots, coupling and seam friction, dead or duplicated surface |
| Performance | Slow CI, slow tests, slow builds, known-slow runtime paths named by telemetry |
| Product-level behavior | Error rates, failure-prone user flows, gaps between documented and measured behavior |
| Config / automation outside the codebase | GitHub labels, Actions workflows, synchronizations, branch protections, bot config |
| Claude Code operational setup | Cloud environments, MCP servers, hooks, permission rules, plugin/skill configuration |

**Docs/markdown improvement is OUT**. Owned lanes (`docs-hygiene`, `codebase-health`) cover it;
finding a docs candidate means naming the owning lane, not adding it to this list.

## Evidence ladder

The skill's core mechanic. Every candidate cites its evidence, and its rung on this ladder sets the
confidence attached to the ranking (strongest first):

1. **Measured telemetry**. Production/application metrics, error rates, cost or latency data from
   a Tier 1/2 source.
2. **Repo and CI history**. Churn×complexity hotspots, CI failure ratios and duration trends,
   dependency staleness. Mechanical, reproducible, repo-native.
3. **Structural presence signals**. Test-coverage presence/absence, TODO density, missing
   automation where a class of toil demonstrably recurs.
4. **Model judgment**, the weakest rung: this session's read of the target. Always labeled as
   such, never dressed up as measurement.

Two hard rules follow:

- **Instrument-first.** When the target has no measurement at all (no telemetry, no usable CI
  history, nothing above rung 4), the top-ranked candidate becomes "instrument this so future runs
  can rank on data": a concrete baseline/instrumentation proposal (what to measure, where the
  signal lands), handed to the pipeline like any other improvement. This mirrors the SRE
  error-budget posture: measurement precedes prioritization.
- **Gaps are recorded, never papered over.** An evidence source that is unavailable (no GitHub
  access path, shallow clone, no telemetry configured) produces an explicit evidence-gap line in
  the output. Absence of evidence is reported; it is never fabricated, estimated, or silently
  skipped.

## Evidence sources (tiered, presence-gated)

- **Tier 0. Repo-native, always available.** Git churn/hotspot analysis (recipe:
  context/hotspots.md, including its shallow-history gate), CI health via GitHub Actions run data
  (recipe: context/ci-health.md), dependency staleness from the repo's own manifests,
  test-coverage presence, TODO density. These ship with the skill and need nothing installed.
- **Tier 1. Local Claude Code telemetry.** When `harness-ops:observability` is installed, consult
  it for session/cost/hook telemetry relevant to the operational-setup dimension.
- **Tier 2. Configured application telemetry.** Whatever MCP telemetry sources the consumer
  declares through the `.claude/improvement.md` config cascade (team file + `.local` overlay +
  user-global; key contract in the plugin's reference/config.md). Never hardcode a vendor; if no
  source is configured, Tier 2 is an evidence gap, and product-level candidates fall back down the
  ladder.

**GitHub access-path probe ladder.** For CI and repo-platform data, probe in order: GitHub MCP
tools (`actions_*` and repo tools) → `gh` CLI → none. On "none", record the evidence gap and rank
without CI evidence, never reconstruct CI health from guesswork.

## Lane delegation as scan input

Where an installed specialized finder covers a dimension more deeply, consult it presence-gated and
fold its findings into this skill's candidate list as inputs. Delegate, never re-inline its
method:

- `architecture:improve` (deepening lens). Depth for the code/architecture dimension.
- `harness-config:audit-automation-gaps`. Depth for the Claude Code operational-setup dimension.
- `/code-metrics:audit-duplication`, when it is among the available skills. Copy count and clone
  trend for the code dimension: run it with `--json --keep --all` and read the document it prints
  (`--keep` keeps that document as the next run's trend baseline). Each clone class's copy count is
  its number of instances; code-metrics computes `trend`, including the lists of new and grown
  classes, and this skill reads only that, never an earlier report. Copy count ranks spread (context/ranking.md). A growing class becomes a
  candidate whose next step is a lint proposal, written through the findings hand-off under
  `<memory_dir>/improvement/<branch-slug>/` (context/unattended.md "Growing clone classes"). When
  code-metrics is not available, or no detector ran, record a `gap:` line for duplication.
- Other installed finders that announce an improvement-shaped scan may be consulted the same way.

Delegated findings keep their lane attribution in the evidence citation, and they compete in the
same ranked list as native candidates. Where no lane is installed, the skill's own Tier 0 scan for
that dimension stands alone. Reuse-or-replace: never re-implement what an owned lane already does.

In unattended mode, consult only lanes that run without interaction; a lane whose flow is
interview- or confirmation-driven is skipped with a `gap:` line naming it, and Tier 0 stands
alone for that dimension, never simulate a user to drive an interactive lane.

## Candidate output shape

One ranked list, highest value-to-effort first. Every row carries:

| Field | Content |
|---|---|
| Rank | Position; the highest-impact candidate leads |
| Candidate | One-line improvement statement, concrete enough to hand to an interview |
| Dimension | Which scan dimension it belongs to |
| Size | S / M / L |
| Evidence | Citation: source + specifics (e.g. "hotspot: 14 commits/90d × high indentation"), and its ladder rung |
| Confidence | Derived from the evidence rung, stated plainly |
| Value-to-effort | WSJF-style rationale: cost of delay (value, urgency, risk reduction) against job size |

Scoring and dedupe mechanics: context/ranking.md. Evidence-gap lines appear after the list so the
reader knows what the ranking could not see.

## Interactive flow

1. Present the ranked candidate list (shape above), evidence gaps included.
2. The user picks a candidate.
3. Interview on the pick. Invoke `/planning:interview` via the Skill tool when available, to reach a shared shape:
   what improvement, why now, what evidence, what done looks like.
4. Hand off to the pipeline, invoking each via the Skill tool: `/discovery:explore` (internal
   unknowns) or `/discovery:research` (external unknowns) as needed, then `/planning:plan`. The handoff artifact is the interview's
   output, with the candidate's evidence citation attached. A pick that fits one small PR may
   instead go to `/improvement:improve`, invoked via the Skill tool with the candidate as its
   target.
5. Offer the remainder: unpicked candidates can be filed via `/work-items:track` when installed; the user decides which, if any.

Where a named pipeline skill is not installed in the consuming project, summarize the equivalent
handoff shape inline instead of blocking, but absence of a pipeline skill is never license to
implement the improvement in this session.

## Unattended mode

Entered only when the **caller declares it** in the invocation prompt (a routine wrapper, a
scheduled job, an orchestrating skill), never sniffed from the environment, per the fleet's
declared-by-the-caller convention. In unattended mode:

- **No questions.** No interview, no picks, no confirmation prompts. Decisions resolve by the
  defaults below or by the invocation prompt's overrides.
- **The report is persisted**, the full ranked list plus evidence-gap lines, under
  `${CLAUDE_PLUGIN_DATA}`, keyed per project per the plugin-data-report-keying convention (report
  shape and keying: context/unattended.md).
- **Top candidates are filed** via `work-items:track` when installed (absent tracker = report
  only, noted in the report). Filing behavior:
  - *Dismissed-candidate memory, at candidate assembly*. Candidates an operator previously
    dismissed are suppressed before ranking, so they never consume a cap slot or a tracker query.
    A soft default the invocation prompt can override.
  - *Dedupe against open work items, at filing time*. Search before creating each item. Baseline
    behavior, not a tuning knob; filing a duplicate is a bug.
  - *Adaptive filing cap*, a soft default bounding how many items one run files (following
    `work-items:work-loop`'s adaptive-cap precedent), overridable by the invocation prompt.

  Consultation order and its rationale: context/ranking.md.
- **Nothing else mutates, and nothing self-disposes.** The run is read-only apart from the report,
  the filed items, and, when code-metrics is enabled, the kept duplication report and the
  clone-growth findings file (with its memory-root `.gitignore`) that the verb contract below names; it never picks a candidate, never prioritizes the queue, never starts
  implementation. Prioritization of filed items is human-gated always, the autonomy catalog's
  `tech-debt-sweep` C1 contract.

## Execution requests

"Go implement this", interactively or as a follow-up, routes through the pipeline, never through
this skill's own hands: interview the pick → `/discovery:explore` / `/discovery:research` →
`/planning:plan` → `/implementation:implement` → `/verification:confirm`, each delegated to its
skill by invoking it via the Skill tool. An execution request changes where the handoff goes,
not what this skill is allowed to touch.

## What this skill does NOT do / Skip when

Reuse-or-replace posture: each boundary below names an owned lane this skill delegates to or steps
aside for. It re-implements none of them.

| Skip when the ask is | Owned by | Why not here |
|---|---|---|
| Single-lens architecture depth (shallow modules, Design-It-Twice) | `architecture:improve` | That lens is consulted as a scan input; going deep on architecture alone is its job |
| Doing one improvement now ("improve this", "fix one thing") | `improvement:improve` | This skill ranks and never edits; `improve` picks one gap and ships it as one PR |
| Applying small safe code edits | `code-tidying:tidy` | This skill never edits; tidying mutates by contract |
| Verifying docs/config/code drift claims | `codebase-health:audit` | Claim verification, not improvement discovery |
| Reviewing a diff before merge | `review:fanout` | Diff-scoped and reactive; this skill scans existing state proactively |
| Sweeping TODO/FIXME markers into items | `work-items:scan-todos` | Marker sweep is one narrow signal; here TODO density is evidence, not the deliverable |

**Verb contract.** `find` never edits the target's tracked files. What it writes depends on the
mode:

- **Interactive** (bare invocation): it reports and stops, apart from the code-metrics writes
  below.
- **Unattended**: the caller's declaration IS the explicit mutation override, the same shape as
  the `audit` verb's autofix override, and it authorizes exactly two more things: the report
  persisted under `${CLAUDE_PLUGIN_DATA}/find/<state-key>/` (with the dismissed-candidate memory
  beside it) and presence-gated work-item filing.
- **Either mode, only when code-metrics is enabled**:
  - `/code-metrics:audit-duplication --json --keep`, which this skill runs, keeps its report in
    code-metrics' own data directory, `reports/<state-key>/audit-duplication-<UTC stamp>.json`
    (code-metrics keeps the newest 20 per project), the baseline of the next run's trend;
  - for a growing clone class, this skill writes one review-findings file,
    `<memory_dir>/improvement/<branch-slug>/<UTC stamp>-clone-growth.md`, and, on its first
    memory-tier write, a `.gitignore` containing `*` in `<memory_dir>` when that file is absent
    (context/unattended.md "Growing clone classes").

No other mutation exists in any mode; there is no flag, prompt, or mode that makes this skill edit
the target's tracked files.

## Spoke paths

The `context/` files write the plugin's root directory as `<plugin-root>`, which is
`${CLAUDE_PLUGIN_ROOT}`. Put that path in place of the placeholder before running a command or
writing it into a brief. Those files arrive through the Read tool as plain bytes, so a `${…}` token
in them would reach the Bash tool unsubstituted, and the Bash tool's environment has no
`CLAUDE_PLUGIN_ROOT` to expand it from. Basis: the plugins reference,
<https://code.claude.com/docs/en/plugins/manifest-reference#where-each-variable-resolves>, verified
2026-10-07; recheck when that table adds supporting files to where a `${…}` reference resolves.

## Next

- Picked candidate fits one small PR: /improvement:improve TARGET.
- Picked candidate needs design or several PRs: /planning:interview.

## Gotchas

Known traps, seeded from the research this skill was grounded on:

- **Shallow or truncated clones poison churn rankings.** The hotspot recipe's history-depth gate
  (context/hotspots.md) runs first; a window the history does not cover downgrades churn to a
  recorded evidence gap. Confidently-wrong rankings from partial history are worse than no
  ranking.
- **Never call the Actions `/timing` endpoint**. GitHub marks it as closing down; the dated record
  for that, and for the documented 1,000-result bound behind the windowing rule, is in
  context/ci-health.md. CI health iterates `/actions/runs` by `created` date windows (never deep
  pagination) and derives failure ratios, duration trends, and `run_attempt` retries per that file.
- **Unattended is declared, never detected.** There is no supported way to observe
  non-interactivity; guessing it converts an interactive user's session into a silent filing run.
- **No access path ≠ healthy CI.** A missing GitHub access path is an evidence-gap line, not a
  reason to estimate CI health from the working tree's vibes.
Pliki w paczce (13)
  • SKILL.md 18 KB
  • context/ci-health.md 8 KB
  • context/hotspots.md 8 KB
  • context/ranking.md 6 KB
  • context/unattended.md 11 KB
  • evals/evals.json 9 KB
  • evals/fixtures/disconnected-admin-export/README.md 1 KB
  • evals/fixtures/disconnected-admin-export/config/flags.json 1 KB
  • evals/fixtures/disconnected-admin-export/db/schema.sql 1 KB
  • evals/fixtures/disconnected-admin-export/src/db.js 1 KB
  • evals/fixtures/disconnected-admin-export/src/flags.js 1 KB
  • evals/fixtures/disconnected-admin-export/src/admin/routes.js 1 KB
  • evals/fixtures/disconnected-admin-export/src/reports/csv-exporter.js 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · melodic-software/claude-code-plugins84MIT
bibryam/universal-skill-finder100MIT
gouthamk16/clipper96MIT
albygira-cmyk/claude-brain-kit96MIT
Jamaalx/claude-chat-namer95MIT
infinum/arkive90Apache-2.0
FYClamityDestiny/vetted85MIT

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

  • 84scan-todos
    Przeszukuje komentarze w kodzie źródłowym pod kątem znaczników TODO, FIXME, HACK i XXX i dla każdego rozwiązuje problem lub zakłada zgłoszenie.
  • 100sweep
    Szuka w kodzie pozostałości debugowania i problemów jakości, takich jak console.log, debugger czy TODO, z opcją poprawy bezpiecznych wzorców.
  • 90improve
    Przegląda kod jako starszy doradca i zamienia najcenniejsze ustalenia w plany wdrożenia dla innych agentów (błędy, bezpieczeństwo, wydajność, testy, dług techniczny, architektura), bez implementowania czegokolwiek.
  • 100arn-assessing
    Przeprowadza techniczną ocenę kodu: szuka długu technicznego, niezgodności ze wzorcami i możliwych usprawnień, a następnie układa plan poprawek.
  • 100improve
    Działa jako starszy doradca nad bazą kodu: czyta ją, ustala kolejność napraw i pisze samodzielne plany dla innych agentów, bez edycji źródeł.
  • 100dev-code-quality
    Skanuje bazę kodu pod kątem duplikacji, nadmiarowości i możliwości poprawy, wskazując cele refaktoryzacji i ogólny stan kodu.

Uwagi i zgłoszenia

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