mutation-testing

Compute mutation scores and classify survived mutants from test runs.

1|Updated May 6, 2026
One-click install
npx skills add https://github.com/jacob-balslev/skill-graph --skill mutation-testing-jacob-balslev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: mutation-testing
Source: https://github.com/jacob-balslev/skill-graph/tree/main/marketplace/skills/mutation-testing
Command: npx skills add https://github.com/jacob-balslev/skill-graph --skill mutation-testing-jacob-balslev

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Mutation testing identifies behavioral gaps in a test suite by asking whether tests fail when small, realistic changes (mutants) are introduced, revealing where coverage exists but verification is missing.

Core Features & Use Cases

  • Mutation-score measurement: compute killed mutants / total non-equivalent mutants to quantify how well tests detect defects.
  • Survived-mutant diagnostics: generate a directly actionable list of test gaps (or classify survivors as equivalent mutants or intentional non-tests).
  • Selective & incremental strategies: use curated operator subsets and diff-aware execution (e.g., PIT/Stryker) to keep CI runs practical for large codebases.
  • Coverage vs verification distinction: explicitly treat coverage as a floor (reach) and mutation as the verification signal (detect), preventing Goodhart-style score gaming.

Quick Start

Use mutation-testing when you want to determine whether your existing tests would catch a defect by running incremental mutation testing on the changed code in your next CI run.

Frequently Asked Questions about mutation-testing

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is mutation testing and how does it measure test suite quality?

Mutation testing evaluates test suite quality by introducing small program changes, called mutants, and observing whether existing tests fail to kill them, revealing behavioral gaps where code coverage exists but actual verification is missing.

How do I run mutation testing in CI without slowing down large codebases?

To run mutation testing in CI for large codebases, apply diff-aware execution and curated operator subsets using tools like PIT or Stryker, enabling selective and incremental mutation runs that scale practically without testing unchanged code.

Why does high code coverage not guarantee my tests catch defects?

High code coverage only measures code reach, whereas mutation testing provides the verification signal by introducing mutants to check if tests actually fail, distinguishing between executed code and properly verified behavior.

How do I handle survived mutants and equivalent mutants in mutation testing?

Survived mutants are handled by generating an actionable list of test gaps to fix, while equivalent mutants, which produce identical behavior, must be identified and excluded from the mutation score computation to ensure accurate test suite verification metrics.

Can I use PIT or Stryker for incremental mutation testing on changed code?

Yes, you can use PIT or Stryker for incremental mutation testing by applying diff-aware strategies that selectively target only the changed code in your CI run, keeping execution practical for large codebases while verifying new behavior.