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.
- Autor
- melodic-software ↗
- Repozytorium
- claude-code-plugins ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 26.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 2
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 3
Brak sygnałów. Repozytorium zmienione 26.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
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
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
- Repository context. Gather first
- Purpose
- Arguments
- Process
- Output
- Next
- What this skill does NOT do
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
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · melodic-software/claude-code-plugins | 84 | MIT |
| mlophez/polix-ai | 100 | Apache-2.0 |
| jeremylongshore/tons-of-skills-marketplace | 100 | MIT |
| duronext/jig | 100 | MIT |
| rjmurillo/ai-agents | 100 | MIT |
| rjmurillo/ai-agents | 100 | MIT |
| rjmurillo/ai-agents | 100 | MIT |
| xoai/sage | 100 | MIT |
| JoDi-27/JoDi-SDD | 100 | MIT |
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.