Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

plan

/plan

Analizuje zmiany w kodzie i tworzy plan testów: klasyfikuje zmienione pliki według wymaganego typu testu, wskazuje luki w pokryciu i ustala priorytety według ryzyka regresji.

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
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
3
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 robi i kiedy

Analizuje zmiany w kodzie i tworzy plan testów: klasyfikuje zmienione pliki według wymaganego typu testu, wskazuje luki w pokryciu i ustala priorytety według ryzyka regresji.

Wyzwalacze z opisu

test planwhat needs testingwhere are the coverage gapswhat should I test here

Argumenty

/plan [range or scope]
Oryginalny opis (EN)

Analyze code changes and produce a test plan. Classify changed files by required test type, identify coverage gaps, and prioritize by regression risk. Use when: 'test plan', 'what needs testing', 'where are the coverage gaps', 'what should I test here', after /implementation:implement completes, or for PR-prep coverage verification; for writing the tests use /testing:write, for running them /toolchain:check.

Jak działa

  1. Repository context. Gather first
  2. Purpose
  3. Arguments
  4. Process
  5. Output
  6. Next
  7. What this skill does NOT do
Sekcje z nagłówków SKILL.md, w oryginale · 131 linii, 859 słów
Podgląd SKILL.md
---
description: "Analyze code changes and produce a test plan. Classify changed files by required test type, identify coverage gaps, and prioritize by regression risk. Use when: 'test plan', 'what needs testing', 'where are the coverage gaps', 'what should I test here', after /implementation:implement completes, or for PR-prep coverage verification; for writing the tests use /testing:write, for running them /toolchain:check."
argument-hint: "[range or scope]"
user-invocable: true
disable-model-invocation: false
metadata:
  workflow-stage: test
  summary: Classify changes by required test type and coverage gaps
---

## 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`
- Working tree status (empty = clean), `git status --porcelain | head -20`
- Recent commits, `git log --oneline -5`

The pipe is the bound and belongs in the command. A read-time cap ("read only the first 20 entries")
comes too late for whatever the command has already returned inline. What a result returns inline,
and when it arrives as a saved file instead, is [Tools reference § Output limits](https://code.claude.com/docs/en/tools-reference#output-limits)
(as of 2026-10-11; recheck when that section changes what a valid result returns inline).

Treat a failure (not a repository, git unavailable) as an unknown value and carry on. Keep these as
separate body Bash calls rather than pre-compute lines, one command per call. The dated record for
why is the worktree skill's
[reference/gather-block.md § The pre-compute block runs as one shell invocation](https://github.com/melodic-software/claude-code-plugins/blob/main/plugins/source-control/skills/worktree/reference/gather-block.md#the-pre-compute-block-runs-as-one-shell-invocation)
(as of 2026-10-11; recheck when that section's record changes). How injected commands run is
[Extend Claude with skills § How injected commands run](https://code.claude.com/docs/en/skills#how-injected-commands-run)
(as of 2026-10-11; recheck when that section changes the per-command shell, timeout, or output-handling behavior it documents).

## Purpose

Coverage-gap analysis: what needs testing, at what level, and in what priority. Per-ecosystem test structure (frameworks, locations, architecture-test project) comes from the consuming project's testing conventions; infer from existing test projects when undocumented.

## Arguments

`$ARGUMENTS`, optional diff range or scope description. Default: uncommitted changes plus the current branch's commits vs the default branch.

Examples: /testing:plan, /testing:plan HEAD~3, /testing:plan the auth module.

## Process

### 1. Analyze the diff

```bash
git diff --stat HEAD~N   # or appropriate range
git diff --name-only HEAD~N
```

Classify each changed file:

| File type | Testing implication |
|-----------|-------------------|
| Domain entity / value object | Unit tests (behavior, invariants, state transitions) |
| Command/query handler | Unit tests (logic) + integration tests (DI, pipeline) |
| API endpoint | Integration tests (HTTP round-trip, status codes, response shape) |
| Middleware / filter | Integration tests via the ecosystem's HTTP-test harness (e.g. WebApplicationFactory for .NET) |
| Infrastructure (EF, external services, DB clients) | Integration tests with real infrastructure (Testcontainers / Docker Compose when available) |
| Configuration / DI registration | Integration tests (verify resolution, no runtime errors) |
| Project file / build infrastructure changes | Architecture tests (when the project has an architecture-test project) |
| UI components (Blazor, HTML, JS frameworks) | E2E testing via browser automation (see `/testing:run-e2e`) |
| Analyzer / lint rules | Analyzer tests (verify diagnostic output) |
| Parser, serializer, pure transform, collection or stateful class | Property tests beside examples (invariants from the spec, a model or metamorphic relation; see `/testing:write`) |
| Replace, rewrite, migrate or port of existing behavior | Characterization or differential tests first (old output as a pin, intentional differences in a ledger; see `/testing:write`), then the usual rows for the new code |

### 2. Generate the test plan

For each change area, produce (test-name forms follow the project's documented pattern; when undocumented, mirror the ecosystem's idiom, the PascalCase placeholders below are illustrative (.NET/xUnit)):

```markdown
## Test Plan for [branch/PR description]

### Unit tests
- [ ] `{Method}_Should{Behavior}_When{Condition}` — {why this matters}
- [ ] ...

### Integration tests
- [ ] `{Subject}_{Behavior}` — {what this validates}
- [ ] ...

### Architecture tests
- [ ] {Rule}_Should{Constraint} — {if project structure changed}

### Property tests (if parsers, serializers, transforms or stateful classes changed)
- [ ] {Property stated from the spec} — {pattern: model, metamorphic, round trip}

### Pins (if replacing or migrating behavior)
- [ ] {Behavior pinned} — {recorded corpus, comparator, intentional-differences ledger}

### E2E verification (if UI/API changes)
- [ ] Navigate to {endpoint}, verify {behavior}
- [ ] Submit {form}, confirm {response}
- [ ] Screenshot: {page} showing {expected state}

### Not testing (with rationale)
- {File}: pure contract, no behavior to test
- {File}: covered transitively by {consumer test}
```

### 3. Gap analysis

Check existing tests against the plan:

- Are there test files covering the changed code?
- Do existing tests cover the new behavior, or only the old?
- Are architecture tests needed (project structure changes)?
- Would E2E testing catch something automated tests can't?

### 4. Prioritize

Not all gaps are equal. Prioritize by:

1. **Regression risk**. Changes to existing behavior that could break silently
2. **Business criticality**. Core domain logic > utility helpers
3. **Complexity**. Conditional logic, state machines, error paths
4. **Integration points**. Boundaries where components meet

## Output

Present the test plan to the user. Then suggest:

- `/testing:write` for identified unit/integration gaps. **For HIGH/CRITICAL coverage gaps**, the `advisor`-tool checkpoint (when available in the session) applies after the new tests land
- `/testing:run-e2e` for UI/API verification scenarios
- `/testing:write organize` if new test projects are needed

For each planned test, name where its expected value will come from: `testing:test-value` (if enabled).

## Next

/testing:write

Writes the tests the plan names.

## What this skill does NOT do

- **Does not write tests**. `/testing:write`
- **Does not run tests**. `/toolchain:check` (SSOT for CLI invocation)
Pliki w paczce (2)
  • SKILL.md 7 KB
  • evals/evals.json 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · melodic-software/claude-code-plugins84MIT
mlophez/polix-ai100Apache-2.0
jeremylongshore/tons-of-skills-marketplace100MIT
duronext/jig100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
xoai/sage100MIT
JoDi-27/JoDi-SDD100MIT

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

  • 100coverage
    Analizuje luki w pokryciu testami, wskazując, czego nie przetestowano i jakich testów brakuje.
  • 84analyze-test-coverage
    Analizuje luki w pokryciu testami i ustala, które fragmenty kodu warto przetestować w pierwszej kolejności.
  • 100test-coverage-improver
    Analizuje luki w pokryciu testami, znajduje nieprzetestowany kod i generuje brakujące testy.
  • 100automated-test-planning
    Tworzy samodzielny plan testów przez analizę kodu pod kątem luk w pokryciu i przypadków brzegowych, dla gałęzi lub wskazanych plików i katalogów.
  • 100qa-strategy
    Tworzy strategię testów, macierz pokrycia i plan priorytetyzacji opartej na ryzyku, wskazując zakres i głębokość testów.
  • 100qa-team
    Planuje i weryfikuje testy wykraczające poza jednostkowe: strategię E2E, plany testów, analizę luk w pokryciu i testy wydajności.

Uwagi i zgłoszenia

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