New: 97,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

Official agent skill

Test Gap Analysis

by microsoft in microsoft/testfx

Performs pseudo-mutation analysis on production code in any language to find gaps in existing test suites.

OfficialMITAuto-check passedTesting & QA

Install Test Gap Analysis

skills CLI
$ npx skills add microsoft/testfx --skill test-gap-analysis -a claude-code

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

GitHub CLI
$ gh skill install microsoft/testfx test-gap-analysis --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/microsoft/testfx.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/test-gap-analysis .claude/skills/test-gap-analysis && 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-gap-analysis
GitHub stars
1k
Token cost
~4k tokens
SKILL.md length
1,811 words
Files
1
Skills in repo
44
Repo updated
First seen
Licence
MIT

At a glance

Performs pseudo-mutation analysis on production code in any language to find gaps in existing test suites.

  • Works in 6 steps: Detect language and load extension → Gather production and test code → Identify mutation points → …
  • The user asks to find weak tests
  • SKILL.md covers Why Pseudo-Mutation Matters, When to Use, When Not to Use and Inputs, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Test Gap Analysis is an agent skill from microsoft/testfx, published by the product's own GitHub organization. Performs pseudo-mutation analysis on production code in any language to find gaps in existing test suites. Use when the user asks to find weak tests, discover untested edge cases, check if tests would catch a bug, or evaluate test effectiveness through mutation-style reasoning. Analyzes production code for mutation points (boundaries, boolean flips, null/None/nil returns, exception/error removal, arithmetic changes) and checks whether tests would detect each mutation. Polyglot: .NET (MSTest/xUnit/NUnit/TUnit)…

Its SKILL.md is about 4k 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 Unit testing. It works with JUnit, Python, .NET and TypeScript. The repository describes itself as: This repository holds the source code of Microsoft.Testing.Platform (MTP), a lightweight alternative to VSTest, as well as MSTest adapter and framework. The licence is MIT.

When your agent uses it

  • The user asks to find weak tests
  • Discover untested edge cases
  • Check if tests would catch a bug
  • Evaluate test effectiveness through mutation-style reasoning

Example prompts

  • “Use the test-gap-analysis skill to perform pseudo-mutation analysis on production code in any language to find gaps in existing test suites”
  • “/test-gap-analysis”

Requirements

  • Python 3

Workflow steps

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

  1. Detect language and load extension
  2. Gather production and test code
  3. Identify mutation points
  4. Evaluate each mutation against tests
  5. Calibrate findings
  6. Report findings

What it can do on your machine

Read from SKILL.md and the folder at commit 44b9dcc. 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

    No scripts in the folder and no shell commands in SKILL.md.

    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

Test Gap Analysis loads about 4k tokens when it runs. Until then it costs about 252 tokens; SKILL.md has 1,811 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~252
When it runs · the whole SKILL.md, loaded when a task matches
~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); files beside SKILL.md are not scanned.

SKILL.md

The full file from microsoft/testfx at commit 44b9dcc, republished under its MIT licence (© microsoft). 1,811 words, ~4,009 tokens.

Download SKILL.mdSave it as .claude/skills/test-gap-analysis/SKILL.md (or your agent's skills folder).
name
test-gap-analysis
description
Performs pseudo-mutation analysis on production code in any language to find gaps in existing test suites. Use when the user asks to find weak tests, discover untested edge cases, check if tests would catch a bug, or evaluate test effectiveness through mutation-style reasoning. Analyzes production code for mutation points (boundaries, boolean flips, null/None/nil returns, exception/error removal, arithmetic changes) and checks whether tests would detect each mutation. Polyglot: .NET (MSTest/xUnit/NUnit/TUnit), Python (pytest/unittest), TS/JS (Jest/Vitest/Mocha/node:test), Java (JUnit/TestNG), Go, Ruby (RSpec/Minitest), Rust, Swift, Kotlin (JUnit/Kotest), PowerShell (Pester), C++ (GoogleTest/Catch2). DO NOT USE FOR: writing new tests (use code-testing-agent, or writing-mstest-tests for MSTest), detecting anti-patterns (use test-anti-patterns), measuring assertion diversity (use assertion-quality), or running actual mutation testing tools (Stryker, mutmut, PIT, cargo-mutants).
license
MIT

Test Gap Analysis via Pseudo-Mutation

Analyze production code in any supported language by reasoning about hypothetical mutations and checking whether existing tests would catch them. This reveals blind spots where tests pass but would continue to pass even if the code were broken.

Language-specific guidance: Call the test-analysis-extensions skill to discover available extension files, then read the file matching the target codebase (e.g., extensions/dotnet.md, extensions/python.md, extensions/typescript.md). The extension file helps you find test files, recognize framework-specific assertion APIs, and identify language-specific null/None/nil patterns and error-handling idioms that map to the mutation catalog below.

Why Pseudo-Mutation Matters

Code coverage tells you what code ran during tests. It does not tell you whether tests would fail if that code were wrong. A method can have 100% line coverage but zero tests that would catch a sign flip, an off-by-one error, or a removed null check.

Pseudo-mutation analysis asks: "If I changed this line, would any test fail?" When the answer is "no," you've found a test gap.

Coverage MetricWhat It MeasuresWhat It Misses
Line coverageWhich lines executedWhether assertions verify those lines' behavior
Branch coverageWhich branches takenWhether both branches produce different asserted outcomes
Mutation scoreWhether tests detect code changesNothing — this is the gold standard

This skill performs static pseudo-mutation — reasoning about mutations without actually running them — to approximate mutation testing at the speed of code review.

When to Use

  • User asks "would my tests catch a bug in this code?"
  • User wants to find weak or shallow tests
  • User wants to evaluate test effectiveness beyond coverage
  • User asks for mutation testing or mutation analysis
  • User asks "where are my tests blind?"
  • User wants to prioritize which tests to strengthen

When Not to Use

  • User wants to write new tests from scratch (use code-testing-agent for any language, or writing-mstest-tests for MSTest specifically)
  • User wants to detect test anti-patterns like flakiness or poor naming (use test-anti-patterns)
  • User wants to measure assertion variety (use assertion-quality)
  • User wants to run an actual mutation testing framework (Stryker for .NET/JS/TS, mutmut for Python, PIT for Java, go-mutesting for Go, cargo-mutants for Rust, mutant for Ruby) — help them directly with the tool
  • User only wants code coverage numbers (out of scope)

Inputs

InputRequiredDescription
Production codeYesThe source files to analyze for mutation points
Test codeYesThe test files that cover the production code
Focus areaNoA specific mutation category or code region to focus on

Workflow

Step 1: Detect language and load extension

Identify the target codebase's language and test framework. Call the test-analysis-extensions skill and read the matching extension file. The mutation catalog below uses language-neutral concepts; the extension file tells you how each concept maps in the language you are analyzing (e.g., null vs None vs nil vs undefined, throw vs raise vs panic! vs return err).

Step 2: Gather production and test code

Read both the production code and its corresponding test files. If the user points to a directory, identify production/test pairs by convention — defaults differ by language: .cs ↔ *Tests.cs/*.Tests.cs (.NET), foo.py ↔ test_foo.py/foo_test.py (Python), foo.ts ↔ foo.test.ts/foo.spec.ts (JS/TS), Foo.java ↔ FooTest.java/FooTests.java (Java), foo.go ↔ foo_test.go (Go), foo.rb ↔ foo_spec.rb/test_foo.rb (Ruby), lib.rs ↔ inline #[cfg(test)] mod tests or tests/foo.rs (Rust), Foo.swift ↔ FooTests.swift (Swift), Foo.kt ↔ FooTest.kt/FooSpec.kt (Kotlin), Foo.ps1 ↔ Foo.Tests.ps1 (Pester), foo.cpp ↔ foo_test.cpp/test_foo.cpp (C++).

Establish which production methods are exercised by which test methods — trace this through method calls in test code, setup, helper methods, and shared examples.

Step 3: Identify mutation points

Scan the production code and annotate every location where a mutation could reveal a test gap. Use the mutation catalog below.

Boundary Mutations
OriginalMutationWhat it tests
<<=Off-by-one at upper bound
>>=Off-by-one at lower bound
<=<Boundary inclusion
>=>Boundary inclusion
== 0== 1 or <= 0Zero-boundary handling
i < lengthi < length - 1 or i <= lengthLoop boundary
index + 1index or index + 2Index arithmetic
Boolean and Logic Mutations
OriginalMutationWhat it tests
&&||Condition independence
||&&Condition necessity
!conditionconditionNegation correctness
if (x)if (!x)Branch selection
true (constant)falseHardcoded assumption
flag || otherotherShort-circuit first operand
Return Value Mutations
OriginalMutationWhat it tests
return resultreturn null / return None / return nil / return undefinedNull/None/nil handling downstream
return resultreturn default(T) / return T() / return "" / return 0Default value handling
return truereturn falseBoolean return verification
return listreturn new List<T>() / return [] / return Array.Empty<T>() / return make([]T, 0) / return Vec::new() / return @[]Empty collection handling
return countreturn 0 or return count + 1Numeric return verification
return stringreturn "" or return null/None/nilString return verification
return Ok(x)return Err(...) (Rust)Result/error variant
return value, nilreturn zero, err (Go)Error tuple
Exception / Error Removal Mutations
OriginalMutationWhat it tests
throw new ArgumentNullException(...) (.NET) / raise ValueError(...) (Python) / throw new Error(...) (JS) / throw new IllegalArgumentException(...) (Java) / panic!(...) (Rust) / panic(...) (Go) / raise ArgumentError (Ruby) / throw RuntimeException(...) (Kotlin) / throw FooError.bar (Swift) / throw "..." (Pester) / throw std::invalid_argument(...) (C++)(remove entire throw/raise/panic)Guard clause verification
if (x == null) throw ... / if x is None: raise ... / if (!x) throw ... / if x == nil { return err } (Go) / assert!(x.is_some()) (Rust)(remove entire guard)Null/None/nil guard testing
if (!IsValid()) throw ... / if not is_valid(): raise ... / etc.(remove entire check)Validation testing
return err after error check (Go)(remove or swallow error)Error propagation
? operator (Rust).unwrap() or .expect(...)Error short-circuit
Arithmetic Mutations
OriginalMutationWhat it tests
a + ba - bAddition correctness
a - ba + bSubtraction correctness
a * ba / bMultiplication correctness
a / ba * bDivision correctness
a % ba / bModulo correctness
x++x--Increment direction
-valuevalueSign flip
Null / None / Nil-Check Removal Mutations
OriginalMutationWhat it tests
if (x == null) return ... / if x is None: return ... / if (!x) return ... / if x == nil { return ... } / unless x; return; end (Ruby) / if x.is_none() { return ... } (Rust)(remove null/None/nil check)Null path coverage
if (x != null) { ... } / if x is not None: ... / if x: ... / if x != nil { ... } / x?.let { ... } (Kotlin) / if let Some(x) = ... { ... } (Rust)(always enter block)Null/None/nil guard necessity
x ?? defaultValue (.NET/JS/Swift) / x or defaultValue (Python) / x || defaultValue (JS) / x.unwrap_or(defaultValue) (Rust) / x || defaultValue (Kotlin: x ?: defaultValue)x (drop coalescing)Null coalescing coverage
x?.Method() (.NET/Swift/Kotlin) / x && x.method() (JS) / x and x.method() (Python)x.Method()Null-conditional coverage
x! (.NET/TS/Swift) / x!! (Kotlin) / .unwrap() (Rust)xNull-forgiving / unwrap necessity
Show full SKILL.md (805 more words)Show less
Step 4: Evaluate each mutation against tests

For each identified mutation point, reason about whether existing tests would detect the change:

  1. Find covering tests — Which test methods exercise the mutated line? Follow call chains through helpers and setup methods.
  2. Check assertion relevance — Do those tests assert something that would change if the mutation were applied? A test that calls the method but only asserts an unrelated property would NOT catch the mutation.
  3. Classify the mutation as:
VerdictMeaningAction
KilledAt least one test would fail if this mutation were appliedNo action needed — tests are effective here
SurvivedNo test would fail — the mutation would go undetectedThis is a test gap — recommend a test improvement
No coverageNo test exercises this code path at allWorse than survived — the code is untested
EquivalentThe mutation produces identical behavior (e.g., x * 1 → x / 1)Skip — not a real mutation
Step 5: Calibrate findings

Before reporting, apply these calibration rules:

  • Don't flag trivial code. Simple property getters (return _name;), auto-properties, and boilerplate don't need mutation analysis. Focus on logic, conditions, calculations, and error handling.
  • Consider defensive depth. If a null guard has a survived mutation but the caller also checks for null, note the redundancy but rate it lower priority.
  • Equivalent mutations are not gaps. If changing >= to > doesn't alter behavior because the == case is impossible given the domain, mark it Equivalent and skip.
  • Private methods reached through public API are valid targets. Trace through the call chain — a private method called from a tested public method may still have survived mutations if the test doesn't assert the specific behavior affected.
  • Rate by risk, not count. A single survived mutation in payment calculation logic is more important than five survived mutations in logging code.
Step 6: Report findings

Present the analysis in this structure:

  1. Summary — Overall mutation score and key findings:

    | Metric              | Value    |
|---------------------|----------|
| Mutation points      | 42       |
| Killed               | 28 (67%) |
| Survived             | 10 (24%) |
| No coverage          | 2 (5%)   |
| Equivalent (skipped) | 2 (5%)   |

  2. Survived Mutations (Test Gaps) — For each survived mutation, report:

    • Location: File, method, line
    • Mutation category: Boundary / Boolean / Return value / Exception / Arithmetic / Null-check
    • Original code: The current code
    • Hypothetical mutation: What would change
    • Why it survives: Which tests cover this code and why their assertions miss it
    • Recommended fix: A concrete test assertion or new test case that would kill this mutation

    Group by priority: high-risk survived mutations first (business logic, calculations, security checks), lower-risk last (logging, formatting).

  3. No-Coverage Zones — Code paths that no test reaches at all. These are worse than survived mutations.

  4. Killed Mutations (Strengths) — Briefly note areas where tests are effective. Highlight well-tested methods and strong assertion patterns. Don't enumerate every killed mutation — summarize.

  5. Recommendations — Prioritized list:

    • Which survived mutations to address first (by risk)
    • Specific test methods to add or strengthen
    • Patterns the team can adopt to prevent future gaps (e.g., always test boundary values, always assert exception types)

Validation

  • Every mutation point was classified (Killed / Survived / No coverage / Equivalent)
  • Every survived mutation includes the original code, the hypothetical change, and why tests miss it
  • Every survived mutation includes a concrete recommended fix (a test assertion or test case)
  • Equivalent mutations are correctly identified and excluded from the score
  • Trivial code (simple getters, auto-properties) is excluded from analysis
  • Findings are prioritized by risk, not just listed in source order
  • Report includes strengths (killed mutations) alongside gaps
  • Mutation categories are correctly labeled

Common Pitfalls

PitfallSolution
Analyzing trivial codeSkip auto-properties, simple getters, @dataclass/record/data class accessors, #[derive] impls — focus on logic
Reporting equivalent mutations as gapsIf the mutation doesn't change behavior, it's not a gap — mark Equivalent
Ignoring call chainsA private/internal/unexported helper called from a tested public method is reachable — trace the chain
Over-counting mutations in generated codeSkip auto-generated code (*.g.cs, *.designer.cs, *_pb.go, *.pb.dart), designer files, migration files, generated mocks/stubs
Recommending a new test for every survived mutationMultiple survived mutations in the same method often share a single missing test — recommend one test that kills several
Ignoring production contextA survived mutation in ToString() / __repr__ / toString() formatting is less important than one in CalculateTotal() — prioritize by business risk
Claiming 100% kill rate is requiredSome mutations in low-risk code are acceptable to leave — acknowledge this in the report
Not considering integration with other skillsIf gaps are found, mention that code-testing-agent (any language) or writing-mstest-tests (MSTest-specific) can help write the missing tests, and test-anti-patterns can audit existing test quality
Forgetting Go's error idiomRemoving if err != nil { return err } is a valid mutation target only when the function actually does something else with err (e.g., wrap, log, branch). Bare passthroughs in idiomatic Go are not meaningful gaps.
Forgetting Rust's ? operator? propagates Err/None short-circuits. Mutating expr? → expr.unwrap() panics instead of returning — flag as Exception/Panic mutation when tests should observe the propagated error.

© microsoft, 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 .agents/skills/test-gap-analysis of microsoft/testfx.

Open the folder on GitHubat commit 44b9dcc

Compare with similar skills

Test Gap Analysis 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 Gap Analysis compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Test Gap Analysis this skillmicrosoft/testfx1k—~4kAutomated safety check: PassMIT
TDD Guidealirezarezvani/claude-skills28k—~3.4kAutomated safety check: PassMIT
TDD GuideLeoYeAI/openclaw-master-skills2.2k—~1.4kAutomated safety check: PassMIT
TDD GuideaAAaqwq/AGI-Super-Team1052 repos~1.1kAutomated safety check: PassMIT
Testing Unityonatangross/orchestkit288—~2.4kAutomated safety check: PassMIT
Error Explanation GeneratorArabelaTso/Skills-4-SE253—~3.8kAutomated safety check: PassApache-2.0

Similar skills

  • TDD Guide

    alirezarezvani/claude-skills

    Test-driven development skill for writing unit tests, generating test fixtures and mocks, analyzing coverage gaps, and guiding red-green-refactor workflows across Jest, Pytest, JUnit, Vitest, and…

    28k GitHub stars~3.4k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed

  • TDD Guide

    LeoYeAI/openclaw-master-skills

    Test-driven development skill for writing unit tests, generating test fixtures and mocks, analyzing coverage gaps, and guiding red-green-refactor workflows across Jest, Pytest, JUnit, Vitest, and…

    2.2k GitHub stars~1.4k tokensUpdated 2 mo ago
    Testing & QAAuto-check passed

  • TDD Guide

    aAAaqwq/AGI-Super-Team

    Test-driven development workflow with test generation, coverage analysis, and multi-framework support

    105 GitHub starsUsed in 2 repos~1.1k tokens
    Testing & QAAuto-check passed

  • Testing Unit

    yonatangross/orchestkit

    Unit testing patterns for isolated business logic tests — AAA pattern, parametrized tests (test.each, @pytest.mark.parametrize), fixture scoping (function/module/session), mocking with MSW/VCR at…

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

  • Error Explanation Generator

    ArabelaTso/Skills-4-SE

    Explains test failures and provides actionable debugging guidance.

    253 GitHub stars~3.8k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed

  • Assertion Synthesizer

    ArabelaTso/Skills-4-SE

    Generate test assertions from existing code implementation. An agent skill from ArabelaTso/Skills-4-SE.

    253 GitHub stars~2.9k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed

More from microsoft/testfx

All 44 skills in this repo

  • Directory Build Organization

    microsoft/testfx

    Official

    Guide for organizing MSBuild infrastructure with Directory.Build.props, Directory.Build.targets, Directory.Packages.props, and Directory.Build.rsp.

    1k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

  • Binlog Failure Analysis

    microsoft/testfx

    Official

    Analyze MSBuild binary logs to diagnose build failures. An agent skill from microsoft/testfx.

    1k GitHub starsUsed in 3 repos~730 tokens
    Auto-check passed

  • Coverage Analysis

    microsoft/testfx

    Official

    Project-wide code coverage and CRAP (Change Risk Anti-Patterns) score analysis for .NET projects.

    1k GitHub stars~7.3k tokensUpdated today
    Auto-check passed

  • Incremental Build

    microsoft/testfx

    Official

    Guide for optimizing MSBuild incremental builds. An agent skill from microsoft/testfx.

    1k GitHub starsUsed in 3 repos~3.7k tokens
    Auto-check passed

  • Msbuild Modernization

    microsoft/testfx

    Official

    Guide for modernizing and migrating MSBuild project files to SDK-style format.

    1k GitHub starsUsed in 3 repos~4.3k tokens
    Auto-check passed

  • Msbuild Antipatterns

    microsoft/testfx

    Official

    Catalog of MSBuild anti-patterns with detection rules and fix recipes.

    1k GitHub stars~4.5k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Test Gap Analysis

What does Test Gap Analysis do?

Performs pseudo-mutation analysis on production code in any language to find gaps in existing test suites. Test Gap Analysis is an agent skill from microsoft/testfx, published by the product's own GitHub organization. Performs pseudo-mutation analysis on production code in any language to find gaps in existing test suites.

When should I use Test Gap Analysis?

Test Gap Analysis fits situations like: the user asks to find weak tests; discover untested edge cases; check if tests would catch a bug; evaluate test effectiveness through mutation-style reasoning.

How do I install Test Gap Analysis in Claude Code?

Run `npx skills add microsoft/testfx --skill test-gap-analysis -a claude-code`. Or copy the skill folder (.agents/skills/test-gap-analysis in microsoft/testfx) into .claude/skills/test-gap-analysis in your project. Claude Code loads it when a task matches its description.

How do I install Test Gap Analysis in Codex?

Run `npx skills add microsoft/testfx --skill test-gap-analysis -a codex`. Or copy the skill folder (.agents/skills/test-gap-analysis in microsoft/testfx) into .agents/skills/test-gap-analysis in your project. Codex loads it when a task matches its description.

Can I use Test Gap Analysis 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 microsoft/testfx --skill test-gap-analysis -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-gap-analysis, .gemini/skills/test-gap-analysis, .github/skills/test-gap-analysis and .opencode/skills/test-gap-analysis in your project.

What does Test Gap Analysis need to run?

SKILL.md names no scripts, command-line tools or credentials: Test Gap Analysis is instructions for the agent only. Our summary lists: Python 3.

Does Test Gap Analysis 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 Test Gap Analysis 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 Gap Analysis use?

Test Gap Analysis 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 Test Gap Analysis use?

About 4k tokens (SKILL.md is roughly 16k 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 Gap Analysis?

Skills that share tags, products or a category with Test Gap Analysis: TDD Guide (alirezarezvani/claude-skills, 28k stars), TDD Guide (LeoYeAI/openclaw-master-skills, 2.2k stars), TDD Guide (aAAaqwq/AGI-Super-Team, 105 stars) and Testing Unit (yonatangross/orchestkit, 288 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Test Gap Analysis?

microsoft (a GitHub organization, an official publisher) maintains it in microsoft/testfx, which has 1,047 GitHub stars. The repository holds 44 skills in this directory. The repository was last updated on October 7, 2026.

Source: microsoft/testfx on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.