Agent skill

Running Mutation Tests

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

Execute mutation testing to evaluate test suite effectiveness.

MITAuto-check passedTesting & QA

Install Running Mutation Tests

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-mutation-tests -a claude-code

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

GitHub CLI
$ gh skill install jeremylongshore/tons-of-skills-marketplace running-mutation-tests --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/skills/.curated/running-mutation-tests .claude/skills/running-mutation-tests && 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
running-mutation-tests
GitHub stars
2.8k
Token cost
~1.4k tokens
SKILL.md length
544 words
Files
8 (incl. scripts, references, assets)
Skills in repo
3,342
Repo updated
First seen
Licence
MIT

At a glance

Execute mutation testing to evaluate test suite effectiveness.

  • Works in 7 steps: Verify the existing test suite passes… → Configure the mutation testing tool → Select target files for mutation → …
  • Performing specialized testing
  • SKILL.md covers Overview, Prerequisites, Instructions and Output, plus 3 more sections
  • Runs Python scripts from its folder; calls npx, mvn and npm

What it does

Running Mutation Tests is an agent skill from jeremylongshore/tons-of-skills-marketplace. Execute mutation testing to evaluate test suite effectiveness. Use when performing specialized testing. Trigger with phrases like "run mutation tests", "test the tests", or "validate test effectiveness".

Its SKILL.md is about 1.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 10 other files, including scripts, reference files and assets (for example `assets/README.md`, `assets/config_template.yaml` and `assets/example_mutation_results.json`). Compatibility notes: Designed for Claude Code

It sits in Testing & QA, covering Test coverage and Test generation. 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

  • Performing specialized testing
  • With phrases like run mutation tests
  • Validate test effectiveness

Example prompts

  • “run mutation tests”
  • “test the tests”
  • “validate test effectiveness”
  • “/running-mutation-tests”

Requirements

  • Python 3
  • Node.js
  • Compatibility (from SKILL.md): Designed for Claude Code
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Grep, Glob, Bash(test:mutation-*)

Workflow steps

7 steps, taken from the first numbered list in SKILL.md.

  1. Verify the existing test suite passes completely
  2. Configure the mutation testing tool
  3. Select target files for mutation
  4. Run the mutation testing suite
  5. Analyze the mutation report
  6. For each surviving mutant, determine the appropriate action
  7. Set mutation score thresholds (recommended: 80% kill rate) and integrate into CI as a quality gate.

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
    • Grep
    • Glob
    • Bash(test:mutation-*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • npx
    • mvn
    • npm

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

  • Network

    Links to these hosts (documentation or services it may open):

    • github.com
    • stryker-mutator.io
    • pitest.org
    • en.wikipedia.org

    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.

  • Compatibility

    Designed for Claude Code

    From compatibility in the SKILL.md frontmatter.

Context cost

Running Mutation Tests loads about 1.4k tokens when it runs, and up to ~1.4k if it reads all its reference files. Until then it costs about 57 tokens; SKILL.md has 544 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~57
When it runs · the whole SKILL.md, loaded when a task matches
~1.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~1.4k

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); the scripts in this folder are not scanned.

SKILL.md

The full file from jeremylongshore/tons-of-skills-marketplace at commit cfae287, republished under its MIT licence (© jeremylongshore). 544 words, ~1,425 tokens.

Download SKILL.mdSave it as .claude/skills/running-mutation-tests/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.
name
running-mutation-tests
description
Execute mutation testing to evaluate test suite effectiveness. Use when performing specialized testing. Trigger with phrases like "run mutation tests", "test the tests", or "validate test effectiveness".
allowed-tools
Read, Write, Edit, Grep, Glob, Bash(test:mutation-*)
compatibility
Designed for Claude Code
version
1.27.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
license
MIT
tags
testing, mutation-tests

Mutation Test Runner

Overview

Execute mutation testing to evaluate the effectiveness of a test suite by systematically introducing small code changes (mutants) and checking whether existing tests detect them. A killed mutant means the tests caught the change; a surviving mutant reveals a testing gap.

Prerequisites

  • Mutation testing framework installed (Stryker, mutmut, PITest, or go-mutesting)
  • Existing test suite with reasonable pass rate (all tests must pass before mutation testing)
  • Source code with functions and logic suitable for mutation (conditionals, arithmetic, return values)
  • Sufficient CI resources (mutation testing runs the test suite once per mutant -- CPU-intensive)
  • Configuration file for the mutation tool specifying target files and test commands

Instructions

  1. Verify the existing test suite passes completely:
    • Run the full test suite and confirm 100% pass rate.
    • Fix any failing or skipped tests before proceeding.
    • Mutation testing is meaningless if the baseline tests are broken.
  2. Configure the mutation testing tool:
    • Stryker: Create stryker.config.mjs with mutate patterns, test runner, and thresholds.
    • mutmut: Configure setup.cfg or pyproject.toml with [mutmut] section.
    • PITest: Add Maven/Gradle plugin with target classes and test configurations.
  3. Select target files for mutation:
    • Focus on business logic modules (not configuration, constants, or type definitions).
    • Exclude auto-generated code, third-party wrappers, and test utilities.
    • Start with a small scope (one module) to validate setup before expanding.
  4. Run the mutation testing suite:
    • Execute npx stryker run, mutmut run, or mvn pitest:mutationCoverage.
    • Monitor progress -- expect long execution times (10-100x normal test runtime).
    • Use incremental mode if available to skip already-tested mutants.
  5. Analyze the mutation report:
    • Killed mutants: Tests detected the change -- indicates strong test coverage.
    • Survived mutants: Tests did not catch the change -- indicates a testing gap.
    • Timed out mutants: Mutation caused an infinite loop -- generally acceptable.
    • No coverage mutants: The mutated code is not exercised by any test.
  6. For each surviving mutant, determine the appropriate action:
    • Write a new test that specifically catches the mutation.
    • Or determine the mutation is equivalent (functionally identical to original) and mark as ignored.
  7. Set mutation score thresholds (recommended: 80% kill rate) and integrate into CI as a quality gate.
Show full SKILL.md (197 more words)Show less

Output

  • Mutation testing report (HTML or JSON) with killed/survived/timed-out counts
  • Mutation score percentage (killed / total non-equivalent mutants)
  • Surviving mutant inventory with file, line, mutation type, and suggested test
  • New test cases written to kill surviving mutants
  • CI configuration with mutation score threshold enforcement

Error Handling

ErrorCauseSolution
Mutation run takes hoursToo many files in scope or slow test suiteNarrow mutate scope to critical modules; use --incremental mode; parallelize with --concurrency
All mutants surviveTests only check for truthiness, not specific valuesStrengthen assertions -- use toBe(42) instead of toBeTruthy(); add boundary checks
Equivalent mutant false positiveMutation produces functionally identical code (e.g., x >= 0 vs x > -1)Mark as equivalent in config; ignore in score calculation; document rationale
Out of memory during runToo many concurrent mutation workersReduce --concurrency setting; increase Node.js --max-old-space-size; reduce shard size
Stryker "initial test run failed"Test suite does not pass cleanly before mutations beginFix all failing tests first; ensure npm test exits 0; check test runner configuration

Examples

Stryker configuration for TypeScript project:

javascript
// stryker.config.mjs
export default {
  mutate: ['src/**/*.ts', '!src/**/*.d.ts', '!src/**/index.ts'],
  testRunner: 'jest',
  jest: { configFile: 'jest.config.ts' },
  reporters: ['html', 'clear-text', 'progress'],
  thresholds: { high: 80, low: 60, break: 50 },
  concurrency: 4,
  timeoutMS: 10000,  # 10000: 10 seconds in ms
};

Example surviving mutant and fix:

Mutant: src/utils/discount.ts:15 -- ConditionalExpression
  Original:  if (total > 100)
  Mutant:    if (total >= 100)
  Status:    SURVIVED

Fix -- add boundary test:
it('does not apply discount at exactly 100', () => {
  expect(calculateDiscount(100)).toBe(0);
});
it('applies discount above 100', () => {
  expect(calculateDiscount(101)).toBe(10.1);
});

mutmut for Python:

bash
# Run mutation testing
mutmut run --paths-to-mutate=src/ --tests-dir=tests/

# View surviving mutants
mutmut results

# Inspect a specific mutant
mutmut show 42

Resources

© 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 7 other files (scripts, references, assets) in skills/.curated/running-mutation-tests of jeremylongshore/tons-of-skills-marketplace.

  • SKILL.md
  • assets/README.md
  • assets/config_template.yaml
  • assets/example_mutation_results.json
  • assets/mutation_report_template.md
  • references/README.md
  • scripts/README.md
  • scripts/mutation_analyzer.py

Open the folder on GitHubat commit cfae287

Compare with similar skills

Running Mutation Tests 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.

Running Mutation Tests compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Running Mutation Tests this skilljeremylongshore/tons-of-skills-marketplace2.8k—~1.4kAutomated safety check: PassMIT
E2E Test ThinkerUniClipboard/UniClipboard1.9k—~1.7kAutomated safety check: PassAGPL-3.0
Ralph Coveragejvm-skills/jvm-skills139—~683Automated safety check: PassApache-2.0
Designing TestsCloudAI-X/opencode-workflow275—~2.9kAutomated safety check: PassMIT
Mutation Testingproffesor-for-testing/agentic-qe495—~1.7kAutomated safety check: PassMIT
Write Testsgnomeria/usbtree691—~622Automated safety check: PassMIT

Similar skills

  • E2E Test Thinker

    UniClipboard/UniClipboard

    Analyze the current branch's diff against main and determine which changes are testable via CLI-based end-to-end tests.

    1.9k GitHub stars~1.7k tokensUpdated today
    Testing & QAAuto-check passed
  • Ralph Coverage

    jvm-skills/jvm-skills

    Run Ralph in coverage mode — iteratively write tests for untested classes until coverage targets are met.

    139 GitHub stars~683 tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • 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
  • Mutation Testing

    proffesor-for-testing/agentic-qe

    Test quality validation through mutation testing, assessing test suite effectiveness by introducing code mutations and measuring kill rate.

    495 GitHub stars~1.7k tokensUpdated yesterday
    Testing & QAAuto-check passed
  • Write Tests

    gnomeria/usbtree

    Author tests that match the repo's stack and existing test style, at the cheapest level that catches the regression.

    691 GitHub stars~622 tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Mutation Test

    jmagly/aiwg

    Run mutation testing to validate test quality beyond code coverage.

    221 GitHub stars~3.2k tokensUpdated 2 days ago
    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 yesterday
    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 yesterday
    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 yesterday
    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 yesterday
    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 yesterday
    Auto-check passed

Categories

Questions about Running Mutation Tests

What does Running Mutation Tests do?

Execute mutation testing to evaluate test suite effectiveness. Running Mutation Tests is an agent skill from jeremylongshore/tons-of-skills-marketplace. Execute mutation testing to evaluate test suite effectiveness.

When should I use Running Mutation Tests?

Running Mutation Tests fits situations like: performing specialized testing; with phrases like run mutation tests; validate test effectiveness.

How do I install Running Mutation Tests in Claude Code?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-mutation-tests -a claude-code`. Or copy the skill folder (skills/.curated/running-mutation-tests in jeremylongshore/tons-of-skills-marketplace) into .claude/skills/running-mutation-tests in your project. Claude Code loads it when a task matches its description.

How do I install Running Mutation Tests in Codex?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-mutation-tests -a codex`. Or copy the skill folder (skills/.curated/running-mutation-tests in jeremylongshore/tons-of-skills-marketplace) into .agents/skills/running-mutation-tests in your project. Codex loads it when a task matches its description.

Can I use Running Mutation Tests 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 running-mutation-tests -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/running-mutation-tests, .gemini/skills/running-mutation-tests, .github/skills/running-mutation-tests and .opencode/skills/running-mutation-tests in your project.

What does Running Mutation Tests need to run?

Going by SKILL.md and its folder, Running Mutation Tests needs Python for the scripts in its folder and the command-line tools its instructions call (npx, mvn and npm). Our summary lists: Python 3; Node.js. Its frontmatter pre-approves these tools: Read, Write, Edit, Grep, Glob, Bash(test:mutation-*). Compatibility (from SKILL.md): Designed for Claude Code.

Does Running Mutation Tests access the network?

SKILL.md names 4 domains. As links in the text: github.com, stryker-mutator.io, pitest.org and en.wikipedia.org. This is read from the text; nothing was executed.

Is Running Mutation Tests 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. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Running Mutation Tests use?

Running Mutation Tests 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 Running Mutation Tests use?

About 1.4k tokens (SKILL.md is roughly 5.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 16 tokens, read only when the agent opens those files.

What are the alternatives to Running Mutation Tests?

Skills that share tags, products or a category with Running Mutation Tests: E2E Test Thinker (UniClipboard/UniClipboard, 1.9k stars), Ralph Coverage (jvm-skills/jvm-skills, 139 stars), Designing Tests (CloudAI-X/opencode-workflow, 275 stars) and Mutation Testing (proffesor-for-testing/agentic-qe, 495 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Running Mutation Tests?

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.