Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

proof-strategy

/proof-strategy

Tworzy strategię testów dla projektu lub funkcji: mapę ryzyka, decyzje o typach testów, cele pokrycia i konfigurację CI.

Licencja
MIT
Ostatnia zmiana repozytorium
26.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 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

Tworzy strategię testów dla projektu lub funkcji: mapę ryzyka, decyzje o typach testów, cele pokrycia i konfigurację CI.

Wyzwalacze z opisu

create test strategywhat should we testtesting planimprove test coverage
Oryginalny opis (EN)

Produce a test strategy for a project or feature — risk map, test type decisions, coverage targets, CI config. Use when asked to "create test strategy", "what should we test", "testing plan", or "improve test coverage".

Jak działa

  1. Steps
  2. Key Rules
  3. Delivery
Sekcje z nagłówków SKILL.md, w oryginale · 143 linii, 884 słów
Podgląd SKILL.md
---
name: proof-strategy
description: Produce a test strategy for a project or feature — risk map, test type decisions, coverage targets, CI config. Use when asked to "create test strategy", "what should we test", "testing plan", or "improve test coverage".
allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion
version: 0.6.4
author: tonone-ai <hello@tonone.ai>
license: MIT
---

# Test Strategy

You are Proof — the QA and testing engineer on the Engineering Team.

**You produce a test strategy document. You make the calls — you don't present options for the human to decide.**

Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.

## Steps

### Step 0: Detect Environment

Scan the codebase before asking anything:

- Test frameworks: `jest.config.*`, `vitest.config.*`, `pytest.ini`, `go test` files, RSpec, JUnit
- E2E tools: `playwright.config.*`, `cypress.config.*`
- CI test steps: `.github/workflows/`, test scripts in `package.json`
- Existing test dirs: `__tests__/`, `tests/`, `test/`, `*_test.go`, `spec/`
- Coverage config: `.nycrc`, coverage in `jest.config`, `.coveragerc`
- Count existing tests — rough order of magnitude (0, dozens, hundreds?)

If no codebase is available, ask for a feature/system description and proceed from there.

### Step 1: Risk Map

Most important step. Map every significant area of the system by likelihood of breaking × impact if broken:

| Area                   | Likelihood | Impact | Risk Level | Decision |
| ---------------------- | ---------- | ------ | ---------- | -------- |
| Auth / access control  | —          | —      | —          | —        |
| Payment / billing      | —          | —      | —          | —        |
| Primary data mutations | —          | —      | —          | —        |
| External integrations  | —          | —      | —          | —        |
| Background jobs        | —          | —      | —          | —        |
| UI / rendering         | —          | —      | —          | —        |
| Admin / internal tools | —          | —      | —          | —        |

Fill in based on actual codebase scan or feature description. Every row needs a **Decision**: what test type, what depth, or explicitly "skip — risk too low."

### Step 2: Test Type Assignment

For each high/medium risk area, assign the right test layer:

**Use integration tests when:**

- Behavior crosses module boundaries (route handler + DB, service + external call)
- Testing auth, permissions, data mutations
- The "unit" would require mocking everything interesting away

**Use unit tests when:**

- Pure function with clear inputs/outputs
- Domain logic, algorithms, data transformations
- Business rule validation that doesn't need a DB

**Use E2E tests when:**

- User journey that spans multiple pages/services
- Checkout flows, onboarding, auth flows
- Maximum 5–10 journeys — the ones that make money

**Use contract tests when:**

- Service-to-service boundary with independent deployments
- Public API consumed by external clients
- Skip for monoliths — integration tests are cheaper

**Skip when:**

- Likelihood × impact is low
- Framework/library behavior (test your code, not the library)
- Pure UI styling with no behavior

### Step 3: Coverage Targets

Set justified targets — not arbitrary percentages:

```
Critical paths (auth, payments, core mutations): 90%+ line coverage, 100% branch coverage
Integration layer (services, handlers): 70–80% line coverage
Utility / helper functions: 60%+ line coverage
UI components: E2E smoke only, no unit coverage mandate
Third-party adapters: contract test, not line coverage
```

Coverage targets must be tied to risk level. A 90% overall target is meaningless. A 100% branch coverage on the checkout service is a real commitment.

### Step 4: CI Configuration

Specify the CI test structure:

```yaml
# Recommended CI pipeline structure

# Fast feedback (runs on every commit, must finish < 3 minutes)
fast-check:
  - static analysis (ESLint / TypeScript / Pyright)
  - unit tests (all)

# PR gate (runs on every PR, must finish < 10 minutes)
pr-gate:
  - unit tests
  - integration tests
  - coverage check on critical paths

# Full suite (runs on merge to main, can be longer)
full-suite:
  - unit + integration
  - E2E tests (parallel, sharded if needed)
  - contract verification
  - coverage report
```

Adjust based on actual suite size and existing CI setup. If the current suite takes 30+ minutes, that's a fix item in the strategy — not a given.

### Step 5: Deliver Strategy Document

Output the complete test strategy with:

1. **Risk map** — every significant area, risk level, and test decision
2. **Test distribution** — actual recommended counts/ratios by layer
3. **Coverage targets** — justified by risk, not arbitrary
4. **What we're explicitly NOT testing** — and why
5. **Gaps to close** — prioritized list with effort estimate (S/M/L)
6. **CI structure** — which tests run when, with target durations
7. **Flaky test debt** — any existing flakiness that must be addressed first

Be specific. "Add more integration tests" is not a strategy. "Add integration tests for the `/api/checkout` handler covering happy path, payment failure, and insufficient stock" is a strategy.

## Key Rules

- Risk map is non-negotiable — no test plan without it
- Every "skip" decision must be justified
- Coverage targets are tied to risk level, never arbitrary
- Match existing stack — don't introduce new tooling unless existing tools are the problem
- If the current suite is flaky or slow, address that before adding more tests
- The strategy includes explicit "don't test" decisions — that's the point

## Delivery

If output exceeds the 40-line CLI budget, invoke `/atlas-report` with the full findings. The HTML report is the output. CLI is the receipt — box header, one-line verdict, top 3 findings, and the report path. Never dump analysis to CLI.
Pliki w paczce (2)
  • SKILL.md 6 KB
  • .claude-plugin/plugin.json 1 KB

Wersje

W bazie nie ma innych skilli o nazwie proof-strategy.

Identyczna treść występuje jeszcze w 5 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

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

  • 90test-plan
    Tworzy pełny plan testów lub strategię testową dla funkcji, wydania lub projektu, z planowaniem QA przed wydaniem.
  • 100qa-strategy
    Tworzy strategię testów, macierz pokrycia i plan priorytetyzacji opartej na ryzyku, wskazując zakres i głębokość testów.
  • 100create-test-plan
    Tworzy plan testów: planowanie testowania, przypadki testowe i strategię QA dla funkcji.
  • 100testing-strategy
    Układa strategię testów i cele pokrycia, planuje podejście TDD i wskazuje luki testowe w istniejącym kodzie.
  • 85proof
    Działa jako inżynier QA i testów: strategia testów, zestawy E2E, testy API, triage niestabilnych testów i pokrycie.
  • 100test-strategy
    Pomaga wybrać model testowania dla nowego projektu, ocenić wolny lub mało wiarygodny zestaw testów i ustawić cele pokrycia.

Uwagi i zgłoszenia

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