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

Proof Strategy

by jeremylongshore in jeremylongshore/tons-of-skills-marketplace

Produce a test strategy for a project or feature — risk map, test type decisions, coverage targets, CI config.

MITAuto-check: notesTesting & QA

Install Proof Strategy

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill proof-strategy -a claude-code

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

GitHub CLI
$ gh skill install jeremylongshore/tons-of-skills-marketplace proof-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/jeremylongshore/tons-of-skills-marketplace.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/ai-agency/tonone/skills/proof-strategy .claude/skills/proof-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
proof-strategy
GitHub stars
2.8k
Token cost
~1.5k tokens
SKILL.md length
602 words
Files
2
Skills in repo
3,342
Repo updated
First seen
Licence
MIT

At a glance

Produce a test strategy for a project or feature — risk map, test type decisions, coverage targets, CI config.

  • Works in 6 steps: Detect Environment → Risk Map → Test Type Assignment → …
  • Asked to create test strategy
  • SKILL.md covers Steps, Key Rules and Delivery
  • Calls go

What it does

Proof Strategy is an agent skill from jeremylongshore/tons-of-skills-marketplace. 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".

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `.claude-plugin/plugin.json`).

It sits in Testing & QA, covering Test strategy, Test coverage and Unit testing. The repository describes itself as: Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com. The licence is MIT.

When your agent uses it

  • Asked to create test strategy
  • What should we test
  • Improve test coverage

Example prompts

  • “create test strategy”
  • “what should we test”
  • “testing plan”
  • “/proof-strategy”

Requirements

  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Detect Environment
  2. Risk Map
  3. Test Type Assignment
  4. Coverage Targets
  5. CI Configuration
  6. Deliver Strategy Document

What it can do on your machine

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

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash
    • Glob
    • Grep
    • WebFetch
    • WebSearch
    • Task
    • TodoWrite

    …and 1 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go

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

  • Network

    No URLs in SKILL.md.

    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

Proof Strategy loads about 1.5k tokens when it runs. Until then it costs about 59 tokens; SKILL.md has 602 words of instructions outside code blocks.

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

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: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion

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 jeremylongshore/tons-of-skills-marketplace at commit cfae287, republished under its MIT licence (© jeremylongshore). 602 words, ~1,504 tokens.

Download SKILL.mdSave it as .claude/skills/proof-strategy/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
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:

AreaLikelihoodImpactRisk LevelDecision
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.

Show full SKILL.md (245 more words)Show less
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.

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

Files

SKILL.md and 1 other file in plugins/ai-agency/tonone/skills/proof-strategy of jeremylongshore/tons-of-skills-marketplace.

  • SKILL.md
  • .claude-plugin/plugin.json

Open the folder on GitHubat commit cfae287

Compare with similar skills

Proof 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.

Proof Strategy compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Proof Strategy this skilljeremylongshore/tons-of-skills-marketplace2.8k—~1.5kAutomated safety check: NotesMIT
Test Experteinverne/dotfiles121—~2.3kAutomated safety check: PassGPL-3.0
Assessing Test Coveragebitwarden/ai-plugins155—~1.1kAutomated safety check: PassCustom licence
Recommending Test Layersbitwarden/ai-plugins155—~2.4kAutomated safety check: PassCustom licence
Studio Testingsupabase/supabase111k—~2.2kAutomated safety check: PassApache-2.0
Dotnet Testingnovotnyllc/dotnet-artisan232—~972Automated safety check: PassMIT

Similar skills

  • Test Expert

    einverne/dotfiles

    Testing methodologies, test-driven development (TDD), unit and integration testing, and testing best practices across multiple frameworks.

    121 GitHub stars~2.3k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed

  • Assessing Test Coverage

    bitwarden/ai-plugins

    Official

    A skill your agent uses when determining what test coverage ALREADY exists for a specific change (a PR, Jira key, Tech Breakdown doc, Testmo CSV, changed paths, or named component).

    155 GitHub stars~1.1k tokensUpdated yesterday
    Testing & QAAuto-check passed

  • Recommending Test Layers

    bitwarden/ai-plugins

    Official

    A skill your agent uses when deciding WHICH new tests a change needs and at WHICH layer each belongs, working from a Jira key, a Testmo CSV, an assessing-test-coverage report, a PR, or a feature…

    155 GitHub stars~2.4k tokensUpdated yesterday
    Testing & QAAuto-check passed

  • Studio Testing

    supabase/supabase

    Official

    Testing strategy for Supabase Studio. An agent skill from supabase/supabase.

    111k GitHub stars~2.2k tokensUpdated yesterday
    Testing & QAAuto-check passed

  • Dotnet Testing

    novotnyllc/dotnet-artisan

    Defines .NET test strategy and implementation patterns across xUnit v3 (Facts, Theories, fixtures, IAsyncLifetime), integration testing (WebApplicationFactory, Testcontainers), Aspire testing…

    232 GitHub stars~972 tokensUpdated 3 days ago
    Testing & QAAuto-check passed

  • Senior QA

    alirezarezvani/claude-skills

    Generates unit tests, integration tests, and E2E tests for React/Next.js applications.

    28k GitHub starsUsed in 1 repo~2.1k tokens
    Testing & QAAuto-check passed

More from jeremylongshore/tons-of-skills-marketplace

All 3,342 skills in this repo

  • Performing Security Code Review

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to conduct a security-focused code review using the security-agent plugin.

    2.8k GitHub starsUsed in 2 repos~1.3k tokens
    Auto-check: notes

  • Adapting Transfer Learning Models

    jeremylongshore/tons-of-skills-marketplace

    Build this skill automates the adaptation of pre-trained machine learning models using transfer learning techniques.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Agent Context Loader

    jeremylongshore/tons-of-skills-marketplace

    Execute proactive auto-loading: automatically detects and loads agents.md files.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Aggregating Performance Metrics

    jeremylongshore/tons-of-skills-marketplace

    Aggregate and centralize performance metrics from applications, systems, databases, caches, and services.

    2.8k GitHub stars~1.2k tokensUpdated today
    Auto-check passed

  • Analyzing Capacity Planning

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to analyze capacity requirements and plan for future growth.

    2.8k GitHub stars~947 tokensUpdated today
    Auto-check passed

  • Analyzing Database Indexes

    jeremylongshore/tons-of-skills-marketplace

    Process use when you need to work with database indexing. An agent skill from jeremylongshore/tons-of-skills-marketplace.

    2.8k GitHub stars~2k tokensUpdated today
    Auto-check passed

Categories

Questions about Proof Strategy

What does Proof Strategy do?

Produce a test strategy for a project or feature — risk map, test type decisions, coverage targets, CI config. Proof Strategy is an agent skill from jeremylongshore/tons-of-skills-marketplace. Produce a test strategy for a project or feature — risk map, test type decisions, coverage targets, CI config.

When should I use Proof Strategy?

Proof Strategy fits situations like: asked to create test strategy; what should we test; improve test coverage.

How do I install Proof Strategy in Claude Code?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill proof-strategy -a claude-code`. Or copy the skill folder (plugins/ai-agency/tonone/skills/proof-strategy in jeremylongshore/tons-of-skills-marketplace) into .claude/skills/proof-strategy in your project. Claude Code loads it when a task matches its description.

How do I install Proof Strategy in Codex?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill proof-strategy -a codex`. Or copy the skill folder (plugins/ai-agency/tonone/skills/proof-strategy in jeremylongshore/tons-of-skills-marketplace) into .agents/skills/proof-strategy in your project. Codex loads it when a task matches its description.

Can I use Proof 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 jeremylongshore/tons-of-skills-marketplace --skill proof-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/proof-strategy, .gemini/skills/proof-strategy, .github/skills/proof-strategy and .opencode/skills/proof-strategy in your project.

What does Proof Strategy need to run?

Going by SKILL.md and its folder, Proof Strategy needs the command-line tools its instructions call (go). Its frontmatter pre-approves these tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion.

Does Proof Strategy access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Proof Strategy safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Proof Strategy use?

Proof Strategy is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Proof Strategy use?

About 1.5k tokens (SKILL.md is roughly 6k 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 Proof Strategy?

Skills that share tags, products or a category with Proof Strategy: Test Expert (einverne/dotfiles, 121 stars), Assessing Test Coverage (bitwarden/ai-plugins, 155 stars), Recommending Test Layers (bitwarden/ai-plugins, 155 stars) and Studio Testing (supabase/supabase, 111k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Proof Strategy?

jeremylongshore (a GitHub user) maintains it in jeremylongshore/tons-of-skills-marketplace, which has 2,827 GitHub stars. The repository holds 3,342 skills in this directory. The repository was last updated on October 10, 2026.

Source: jeremylongshore/tons-of-skills-marketplace on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.