New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Test Strategy

by kid-sid in kid-sid/claude-spellbook

A skill your agent uses when choosing a testing model for a new project, auditing a test suite that is slow or provides low confidence, setting coverage targets, or writing a QA test plan for a…

MITAuto-check passedTesting & QA

Install Test Strategy

skills CLI
$ npx skills add kid-sid/claude-spellbook --skill test-strategy -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install kid-sid/claude-spellbook test-strategy --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/kid-sid/claude-spellbook.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/test-strategy .claude/skills/test-strategy && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
test-strategy
GitHub stars
189
Token cost
~2.7k tokens
SKILL.md length
841 words
Files
1
Skills in repo
52
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when choosing a testing model for a new project, auditing a test suite that is slow or provides low confidence, setting coverage targets, or writing a QA test plan for a…

  • Choosing a testing model for a new project
  • SKILL.md covers When to Activate, Testing Models, Coverage Target Setting and Shift-Left Testing, plus 4 more sections
  • Calls go and git; reaches github.com
  • Auditing a test suite that is slow

What it does

Test Strategy is an agent skill from kid-sid/claude-spellbook. Use when choosing a testing model for a new project, auditing a test suite that is slow or provides low confidence, setting coverage targets, or writing a QA test plan for a release.

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Testing & QA, covering Test generation, Test strategy and Microservices. The repository describes itself as: A curated collection of skills, prompts, and workflows that extend Claude's capabilities — your personal grimoire for AI-powered development. The licence is MIT.

When your agent uses it

  • Choosing a testing model for a new project
  • Auditing a test suite that is slow
  • Provides low confidence
  • Setting coverage targets

Example prompts

  • “/test-strategy”

Requirements

  • Python 3

What it can do on your machine

Read from SKILL.md and the folder at commit a7c2ac9. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Test Strategy loads about 2.7k tokens when it runs. Until then it costs about 49 tokens; SKILL.md has 841 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~49
When it runs · the whole SKILL.md, loaded when a task matches
~2.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from kid-sid/claude-spellbook at commit a7c2ac9, republished under its MIT licence (© kid-sid). 841 words, ~2,656 tokens.

Download SKILL.mdSave it as .claude/skills/test-strategy/SKILL.md (or your agent's skills folder).
name
test-strategy
description
Use when choosing a testing model for a new project, auditing a test suite that is slow or provides low confidence, setting coverage targets, or writing a QA test plan for a release.

Test Strategy

Design a complete testing strategy for any project: choose the right model, set meaningful coverage targets, shift quality left, and plan non-functional testing.

When to Activate

  • Starting a new project and deciding on a testing approach
  • Auditing an existing test suite that is slow or provides low confidence
  • Writing a QA plan or test plan document
  • Deciding how to balance unit vs integration vs E2E tests for a feature
  • Setting coverage targets for a team or project
  • Planning non-functional testing (load, security, accessibility)

Testing Models

Choosing the right testing model is the first decision. Each reflects a different philosophy about where confidence comes from.

The Pyramid (Classic)
        /\
       /E2E\        few (slow, fragile)
      /------\
     /  Integ  \    some
    /------------\
   /    Unit      \  many (fast, reliable)
  /-----------------\
  • Best for: well-defined layers, strong service boundaries, experienced team
  • Risk: integration tests are often underdone; false confidence from high unit coverage
The Trophy (Kent C. Dodds)
        /\
       /E2E\        few
      /------\
     /        \
    / Integra-  \   most  ← emphasis here
   /   tion      \
  /---------\
 /  Unit     \       some
/  (static)   \  type checking, linting
  • Best for: React/frontend apps, services where user behavior drives quality
  • The "integration" layer tests realistic slices (full request/response, not mocked)
The Honeycomb (Spotify / Microservices)
  • Emphasized: service integration tests (call your API, hit a real DB)
  • De-emphasized: pure unit tests (too many mocks = low confidence)
  • Best for: microservices, event-driven systems
Decision Table
ContextRecommended ModelReason
Monolith, complex business logicPyramidUnits test business rules cheaply
Frontend-heavy applicationTrophyIntegration tests reflect user behavior
Microservices (many small services)HoneycombService integration > unit isolation
Data pipelineCustom (mostly integration)Units are trivial; real data matters

Coverage Target Setting

What Coverage Measures
MetricWhat It MeasuresHow to Get It
Line coverageWere these lines executed?--cov, --coverage, go test -cover
Branch coverageWere all if/else paths taken?--branch flag
Mutation coverageDo tests catch logic mutations?mutmut (Python), stryker (TS), go-mutesting
Realistic Targets
Codebase TypeLine Coverage TargetNotes
New greenfield project80%+Enforce from day 1
Adding tests to legacyRaise by 5% per sprintRatchet: never let it drop
Critical path (payments, auth)95%+Include branch coverage
Generated code, migrations, config loadersExclude from measurementNoisy, not meaningful

Rule: coverage is a floor, not a goal. 60% with excellent integration tests > 100% with trivial mocks.

Enforcing Coverage in CI
yaml
# pytest example (pyproject.toml)
[tool.pytest.ini_options]
addopts = "--cov=src --cov-fail-under=80 --cov-branch"

[tool.coverage.report]
omit = ["src/migrations/*", "src/generated/*", "**/config_loader.py"]
json
// Jest example (package.json)
{
  "jest": {
    "coverageThreshold": {
      "global": {
        "lines": 80,
        "branches": 70
      }
    },
    "coveragePathIgnorePatterns": ["/generated/", "/migrations/"]
  }
}
go
// Go example (Makefile)
// go test ./... -coverprofile=coverage.out && go tool cover -func=coverage.out | grep total

Shift-Left Testing

Shift-left = catch defects earlier in the development cycle (before code review, before CI).

TechniqueWhen It RunsWhat It Catches
Type checking (mypy, tsc, go vet)IDE + pre-commitType errors, wrong function signatures
Linting (ruff, eslint, staticcheck)IDE + pre-commitStyle, common bugs, dead code
Pre-commit hooksOn git commitBoth above, secret scanning
Contract testsCI on PRAPI contract violations between services
Property-based testsCIEdge cases the developer didn't think of
Pre-Commit Configuration
yaml
# .pre-commit-config.yaml
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.3.0
    hooks:
      - id: ruff
      - id: ruff-format
  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.9.0
    hooks:
      - id: mypy
  - repo: https://github.com/Yelp/detect-secrets
    rev: v1.4.0
    hooks:
      - id: detect-secrets
Contract Testing (Pact)

Contract tests verify that two services agree on the shape of requests and responses without needing both services running simultaneously.

typescript
// Consumer side (TypeScript/Pact)
const interaction = {
  state: "user 123 exists",
  uponReceiving: "a request for user 123",
  withRequest: { method: "GET", path: "/users/123" },
  willRespondWith: {
    status: 200,
    body: { id: 123, name: like("Alice") },
  },
};
Property-Based Testing
python
# Python / Hypothesis
from hypothesis import given, strategies as st

@given(st.lists(st.integers()))
def test_sort_is_idempotent(lst):
    assert sorted(sorted(lst)) == sorted(lst)

Non-Functional Test Types

TypeWhat It TestsToolsWhen to Run
Load testingBehavior under expected traffick6, Locust, JMeterPre-launch, nightly
Stress testingBehavior beyond capacityk6, GatlingBefore scaling decisions
Soak testingBehavior over extended time (memory leaks)k6, LocustWeekly
Spike testingSudden traffic burst handlingk6Before big events
Security testingVulnerability scanningOWASP ZAP, Snyk, pip-auditEvery CI run (SAST), nightly (DAST)
Accessibility (a11y)WCAG complianceaxe-core, Playwright + axeEvery PR for UI changes
Visual regressionUnintended UI changesPlaywright screenshots, PercyEvery PR for UI changes
Show full SKILL.md (303 more words)Show less
k6 Load Test Example
javascript
// k6 load test
import http from "k6/http";
import { check, sleep } from "k6";

export const options = {
  stages: [
    { duration: "1m", target: 50 },   // ramp up
    { duration: "3m", target: 50 },   // hold
    { duration: "1m", target: 0 },    // ramp down
  ],
  thresholds: {
    http_req_duration: ["p(95)<500"], // 95th percentile under 500ms
    http_req_failed: ["rate<0.01"],   // error rate under 1%
  },
};

export default function () {
  const res = http.get("https://api.example.com/health");
  check(res, { "status is 200": (r) => r.status === 200 });
  sleep(1);
}
Accessibility Testing with Playwright
typescript
// Playwright + axe-core
import { test, expect } from "@playwright/test";
import AxeBuilder from "@axe-core/playwright";

test("homepage has no WCAG violations", async ({ page }) => {
  await page.goto("/");
  const results = await new AxeBuilder({ page })
    .withTags(["wcag2a", "wcag2aa"])
    .analyze();
  expect(results.violations).toEqual([]);
});

Test Plan Template

markdown
# Test Plan: [Feature / Release Name]

## Scope
What is being tested:
- [Feature 1]
- [Feature 2]

## Out of Scope
- [Explicitly excluded items]

## Test Environments
| Environment | URL | Data State |
|-------------|-----|-----------|
| Staging | ... | Anonymized copy of prod |

## Test Types and Owners
| Type | Owner | Tools | When |
|------|-------|-------|------|
| Unit | Dev | pytest/Jest/Go test | Every PR |
| Integration | Dev | Testcontainers | Every PR |
| E2E smoke | QA | Playwright | Post-deploy |
| Load | SRE | k6 | Pre-launch |

## Entry Criteria
- [ ] Feature code merged to main
- [ ] CI green

## Exit Criteria
- [ ] All P0/P1 test cases pass
- [ ] No open CRITICAL/HIGH bugs
- [ ] Coverage >= 80%
- [ ] Smoke tests pass on staging

## Risk Areas
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|-----------|
| ...  | ...       | ...    | ...       |

See also: unit-testing, integration-testing, solution-testing, performance-testing

Red Flags

  • Applying the test pyramid without considering system architecture — the pyramid assumes cheap unit tests; for integration-heavy microservices or event-driven systems, the Honeycomb model often fits better
  • Coverage percentage as the primary quality metric — 90% line coverage can coexist with zero behavior coverage if tests assert on implementation rather than outcomes; track branch coverage and mutation scores
  • E2E tests for edge cases and error paths — edge cases should live in unit or integration tests; E2E tests should cover critical user journeys only, not every conditional branch
  • Consumer-driven contract tests treated as optional — for service-to-service dependencies, a broken contract is a production outage; Pact catches this class of failure in CI before it ships
  • Load and security tests planned for "after launch" — non-functional tests deferred post-launch are perpetually skipped; include them in the Definition of Done for every API feature
  • No test plan before a major release — releases without a test plan have undefined risk; write a one-page plan listing scenarios, owners, and pass/fail criteria before any major release
  • Shared mutable test state across the suite — a test that leaves the database dirty causes cascading failures in subsequent tests; treat test isolation as a first-class constraint

Checklist

  • Testing model chosen (Pyramid/Trophy/Honeycomb) and matches team context
  • Coverage targets defined per layer and enforced in CI
  • Branch coverage measured for critical business logic
  • Pre-commit hooks configured for linting, type-checking, secret scanning
  • Non-functional test types identified (at least: load testing and security scanning)
  • Test plan written for major releases
  • Generated code and config loaders excluded from coverage measurement
  • Test suite runs in under 10 minutes in CI (unit + integration; E2E separate)
  • Contract tests in place for any service-to-service API dependencies
  • Accessibility tests run on every PR touching UI components

© kid-sid, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/test-strategy of kid-sid/claude-spellbook.

Open the folder on GitHubat commit a7c2ac9

Compare with similar skills

Test Strategy next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Test Strategy compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Test Strategy this skillkid-sid/claude-spellbook189—~2.7kAutomated safety check: PassMIT
Designing TestsCloudAI-X/opencode-workflow275—~2.9kAutomated safety check: PassMIT
Test Strategynurettincoban/ai-prd-workflow298—~1.4kAutomated safety check: PassMIT
Bmad Testarch Test Designbmad-code-org/bmad-method-test-architecture-enterprise1043 repos~1.4kAutomated safety check: PassCustom licence
Automated Test Planningtestdouble/han279—~6.7kAutomated safety check: PassMIT
Bmad Tea Testarch Test Designchenjackle45/SayIt114—~231Automated safety check: PassMIT

Similar skills

  • Designing Tests

    CloudAI-X/opencode-workflow

    Guides test strategy, TDD/BDD approaches, test coverage planning, and testing best practices.

    275 GitHub stars~2.9k tokensUpdated 9 mo ago
    Testing & QAAuto-check passed

  • Test Strategy

    nurettincoban/ai-prd-workflow

    Write TEST-STRATEGY.md, a test plan per RFC, before the tests are written.

    298 GitHub stars~1.4k tokensUpdated 6 days ago
    Testing & QAAuto-check passed

  • Bmad Testarch Test Design

    bmad-code-org/bmad-method-test-architecture-enterprise

    Create system-level or epic-level test plans. An agent skill from bmad-code-org/bmad-method-test-architecture-enterprise.

    104 GitHub starsUsed in 3 repos~1.4k tokens
    Testing & QAAuto-check passed

  • Automated Test Planning

    testdouble/han

    Produce a standalone test plan by analyzing code for test coverage gaps and edge cases.

    279 GitHub stars~6.7k tokensUpdated 6 days ago
    Testing & QAAuto-check passed

  • Bmad Tea Testarch Test Design

    chenjackle45/SayIt

    Create system-level or epic-level test plans. An agent skill from chenjackle45/SayIt.

    114 GitHub stars~231 tokensUpdated 8 days ago
    Testing & QAAuto-check passed

  • Manual Test Planning

    testdouble/han

    Produce a plain-language manual test plan from the context supplied to it — an executive summary, a high-level list of named tests, and a detail section per test with the steps a person follows by…

    279 GitHub stars~2.9k tokensUpdated 6 days ago
    Testing & QAAuto-check passed

More from kid-sid/claude-spellbook

All 52 skills in this repo

  • Accessibility

    kid-sid/claude-spellbook

    A skill your agent uses when building or reviewing UI components for keyboard and screen reader compatibility, adding ARIA to custom widgets, auditing a page for WCAG AA conformance, or preparing…

    189 GitHub stars~3.2k tokensUpdated 2 mo ago
    Auto-check passed

  • Agentex

    kid-sid/claude-spellbook

    A skill your agent uses when building, wiring, or debugging an Agentex agent — choosing agent type, configuring acp.py and manifest.yaml, using adk.messages or adk.state, or resolving…

    189 GitHub stars~2.2k tokensUpdated 2 mo ago
    Auto-check: notes

  • AI Engineer

    kid-sid/claude-spellbook

    A skill your agent uses when building production LLM applications — designing RAG pipelines, choosing vector databases, implementing agent orchestration, optimizing cost, or adding AI safety…

    189 GitHub stars~3.7k tokensUpdated 2 mo ago
    Auto-check passed

  • Angular

    kid-sid/claude-spellbook

    A skill your agent uses when building or refactoring Angular applications — choosing between signals, RxJS, and NgRx for state, configuring routing with guards and lazy loading, optimizing change…

    189 GitHub stars~5k tokensUpdated 2 mo ago
    Auto-check passed

  • API Design

    kid-sid/claude-spellbook

    A skill your agent uses when designing new REST endpoints, reviewing an existing API contract, adding pagination or filtering, planning a versioning strategy, or building a public or partner-facing…

    189 GitHub stars~3.6k tokensUpdated 2 mo ago
    Auto-check passed

  • Auth

    kid-sid/claude-spellbook

    A skill your agent uses when implementing login flows, issuing or validating JWTs, setting up OAuth2/OIDC with a provider, designing role-based or attribute-based access control, securing API…

    189 GitHub stars~3.2k tokensUpdated 2 mo ago
    Auto-check passed

Categories

Questions about Test Strategy

What does Test Strategy do?

A skill your agent uses when choosing a testing model for a new project, auditing a test suite that is slow or provides low confidence, setting coverage targets, or writing a QA test plan for a…. Test Strategy is an agent skill from kid-sid/claude-spellbook. Use when choosing a testing model for a new project, auditing a test suite that is slow or provides low confidence, setting coverage targets, or writing a QA test plan for a release.

When should I use Test Strategy?

Test Strategy fits situations like: choosing a testing model for a new project; auditing a test suite that is slow; provides low confidence; setting coverage targets.

How do I install Test Strategy in Claude Code?

Run `npx skills add kid-sid/claude-spellbook --skill test-strategy -a claude-code`. Or copy the skill folder (skills/test-strategy in kid-sid/claude-spellbook) into .claude/skills/test-strategy in your project. Claude Code loads it when a task matches its description.

How do I install Test Strategy in Codex?

Run `npx skills add kid-sid/claude-spellbook --skill test-strategy -a codex`. Or copy the skill folder (skills/test-strategy in kid-sid/claude-spellbook) into .agents/skills/test-strategy in your project. Codex loads it when a task matches its description.

Can I use Test Strategy in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add kid-sid/claude-spellbook --skill test-strategy -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/test-strategy, .gemini/skills/test-strategy, .github/skills/test-strategy and .opencode/skills/test-strategy in your project.

What does Test Strategy need to run?

Going by SKILL.md and its folder, Test Strategy needs the command-line tools its instructions call (go and git). Our summary lists: Python 3.

Does Test Strategy access the network?

SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Test Strategy safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Test Strategy use?

Test Strategy is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Test Strategy use?

About 2.7k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Test Strategy?

Skills that share tags, products or a category with Test Strategy: Designing Tests (CloudAI-X/opencode-workflow, 275 stars), Test Strategy (nurettincoban/ai-prd-workflow, 298 stars), Bmad Testarch Test Design (bmad-code-org/bmad-method-test-architecture-enterprise, 104 stars) and Automated Test Planning (testdouble/han, 279 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Test Strategy?

kid-sid (a GitHub user) maintains it in kid-sid/claude-spellbook, which has 189 GitHub stars. The repository holds 52 skills in this directory. The repository was last updated on August 5, 2026.

Source: kid-sid/claude-spellbook on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.