Agent skill

Analyzing Test Coverage

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

Analyze code coverage metrics and identify untested code paths.

MITAuto-check passedTesting & QA

Install Analyzing Test Coverage

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill analyzing-test-coverage -a claude-code

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

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

At a glance

Analyze code coverage metrics and identify untested code paths.

  • Works in 7 steps: Run the test suite with coverage… → Parse the coverage report and extract… → Identify critical coverage gaps by… → …
  • Analyzing untested code
  • SKILL.md covers Current State, Overview, Prerequisites and Instructions, plus 4 more sections
  • Runs Python scripts from its folder; calls go, node and python3

What it does

Analyzing Test Coverage is an agent skill from jeremylongshore/tons-of-skills-marketplace. Analyze code coverage metrics and identify untested code paths. Use when analyzing untested code or coverage gaps. Trigger with phrases like "analyze coverage", "check test coverage", or "find untested code".

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

It sits in Testing & QA, covering Test coverage. It works with Python. 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

  • Analyzing untested code
  • With phrases like analyze coverage
  • Check test coverage
  • Find untested code

Example prompts

  • “analyze coverage”
  • “check test coverage”
  • “find untested code”
  • “/analyzing-test-coverage”

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:coverage-*)

Workflow steps

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

  1. Run the test suite with coverage instrumentation enabled
  2. Parse the coverage report and extract per-file metrics
  3. Identify critical coverage gaps by prioritizing
  4. Analyze uncovered branches specifically
  5. Generate a prioritized action plan
  6. Compare current coverage against the previous commit or baseline
  7. Write coverage enforcement configuration (coverage thresholds in Jest config, .coveragerc, or CI checks).

What it can do on your machine

Read from SKILL.md and the folder at commit 80f86df. 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:coverage-*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

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

    Shell commands in SKILL.md call:

    • go
    • node
    • python3
    • npx
    • pytest

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

    • istanbul.js.org
    • github.com
    • coverage.readthedocs.io
    • jacoco.org
    • go.dev
    • testing.googleblog.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.

  • Compatibility

    Designed for Claude Code

    From compatibility in the SKILL.md frontmatter.

Context cost

Analyzing Test Coverage loads about 1.4k tokens when it runs, and up to ~1.5k if it reads all its reference files. Until then it costs about 58 tokens; SKILL.md has 513 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~58
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.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 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 80f86df, republished under its MIT licence (© jeremylongshore). 513 words, ~1,449 tokens.

Download SKILL.mdSave it as .claude/skills/analyzing-test-coverage/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
analyzing-test-coverage
description
Analyze code coverage metrics and identify untested code paths. Use when analyzing untested code or coverage gaps. Trigger with phrases like "analyze coverage", "check test coverage", or "find untested code".
allowed-tools
Read, Write, Edit, Grep, Glob, Bash(test:coverage-*)
compatibility
Designed for Claude Code
version
1.24.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
license
MIT
tags
testing, analyzing-test

Test Coverage Analyzer

Current State

!ls package.json pyproject.toml Cargo.toml go.mod 2>/dev/null || echo 'No project manifest found' !node -v 2>/dev/null || python3 --version 2>/dev/null || echo 'No runtime detected'

Overview

Analyze code coverage metrics to identify untested code paths, dead code, and coverage gaps across line, branch, function, and statement dimensions. Supports Istanbul/nyc (JavaScript/TypeScript), coverage.py (Python), JaCoCo (Java), and Go coverage tools.

Prerequisites

  • Coverage tool installed and configured (Istanbul/nyc, c8, coverage.py, JaCoCo, or go test -cover)
  • Test suite that can run with coverage instrumentation enabled
  • Coverage threshold targets defined (recommended: 80% lines, 70% branches)
  • Coverage output format set to JSON or LCOV for programmatic analysis
  • Git history available for coverage trend comparison

Instructions

  1. Run the test suite with coverage instrumentation enabled:
    • JavaScript: npx jest --coverage --coverageReporters=json-summary,lcov
    • Python: pytest --cov=src --cov-report=json --cov-report=term-missing
    • Go: go test -coverprofile=coverage.out ./...
    • Java: Configure JaCoCo Maven/Gradle plugin with XML report output.
  2. Parse the coverage report and extract per-file metrics:
    • Line coverage percentage per file.
    • Branch coverage percentage per file.
    • Function coverage percentage per file.
    • Uncovered line ranges (specific line numbers).
  3. Identify critical coverage gaps by prioritizing:
    • Files with coverage below the threshold (sort ascending by coverage %).
    • Files with high complexity but low coverage (use cyclomatic complexity if available).
    • Recently modified files with decreasing coverage trends.
    • Public API functions and exported modules lacking any tests.
  4. Analyze uncovered branches specifically:
    • Find if/else blocks where only one branch is tested.
    • Identify switch/case statements with missing case coverage.
    • Locate error handling paths (catch, except) never exercised.
    • Check || and && short-circuit conditions.
  5. Generate a prioritized action plan:
    • List top 10 files needing coverage improvement with specific line ranges.
    • Suggest test scenarios for each uncovered branch.
    • Estimate effort (small/medium/large) for each coverage improvement.
  6. Compare current coverage against the previous commit or baseline:
    • Calculate coverage delta per file.
    • Flag files where coverage decreased.
    • Verify new code added since baseline has adequate coverage.
  7. Write coverage enforcement configuration (coverage thresholds in Jest config, .coveragerc, or CI checks).
Show full SKILL.md (189 more words)Show less

Output

  • Coverage summary report with overall and per-file metrics
  • Prioritized list of uncovered code paths with file:line references
  • Coverage delta report comparing against baseline
  • Suggested test cases for top coverage gaps
  • Coverage threshold configuration file for CI enforcement

Error Handling

ErrorCauseSolution
Coverage report shows 0%Tests ran but coverage instrumentation was not enabledVerify --coverage flag is passed; check that source files are not excluded by config
Coverage includes node_modulesCoverage collection scope too broadAdd collectCoverageFrom in Jest config; set --cov=src in pytest; exclude vendor dirs
Branch coverage much lower than line coverageConditional logic is only partially testedWrite tests for both truthy and falsy conditions on each branch; focus on edge cases
Coverage drops after refactorNew code added without corresponding testsSet coverageThreshold with global minimums; add --changedSince for incremental checks
Flaky coverage numbers between runsNon-deterministic test execution skipping code pathsSort tests deterministically; run coverage with --runInBand for consistent results

Examples

Jest coverage configuration with thresholds:

json
{
  "jest": {
    "coverageThreshold": {
      "global": {
        "branches": 70,
        "functions": 80,
        "lines": 80,
        "statements": 80
      },
      "src/utils/": {
        "branches": 90,
        "lines": 95
      }
    },
    "collectCoverageFrom": [
      "src/**/*.{ts,tsx}",
      "!src/**/*.d.ts",
      "!src/**/index.ts"
    ]
  }
}

Coverage gap analysis output:

Coverage Gaps (sorted by impact):
1. src/auth/oauth.ts        Lines: 45%  Branches: 30%  [Lines 42-67, 89-103 uncovered]
   Suggestion: Add tests for token refresh failure and expired session handling
2. src/api/middleware.ts     Lines: 62%  Branches: 41%  [Lines 28-35, 71-80 uncovered]
   Suggestion: Test rate limiting edge cases and malformed header handling
3. src/utils/parser.ts       Lines: 71%  Branches: 55%  [Lines 112-130 uncovered]
   Suggestion: Test malformed input, empty string, and encoding edge cases

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 8 other files (scripts, references, assets) in skills/.curated/analyzing-test-coverage of jeremylongshore/tons-of-skills-marketplace.

  • SKILL.md
  • assets/README.md
  • assets/configuration_template.yaml
  • assets/example_coverage_report.html
  • assets/report_template.html
  • references/README.md
  • scripts/README.md
  • scripts/analyze_coverage.py
  • scripts/generate_report.py

Open the folder on GitHubat commit 80f86df

Compare with similar skills

Analyzing Test Coverage 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.

Analyzing Test Coverage compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Analyzing Test Coverage this skilljeremylongshore/tons-of-skills-marketplace2.8k—~1.4kAutomated safety check: PassMIT
Find Untested Sourcesdotnet/skills5.6k1 repos~3.3kAutomated safety check: PassMIT
Test Coverage Reviewareed1192/finance-news-aggregator149—~2.6kAutomated safety check: PassMIT
Supercovsupercorp-ai/supercov1511 repos~415Automated safety check: PassMIT
OptestPyLops/pylops539—~729Automated safety check: PassLGPL-3.0
Review OpCVCUDA/CV-CUDA2.7k—~481Automated safety check: PassCustom licence

Similar skills

  • Official

    Statically pairs source files with test files to list code that no test references, using Roslyn for C# or tree-sitter for many languages, with no build.

    5.6k GitHub starsUsed in 1 repo~3.3k tokens
    Testing & QAAuto-check passed
  • Test Coverage Review

    areed1192/finance-news-aggregator

    Audit, plan, write, and verify unit tests for Python projects using pytest.

    149 GitHub stars~2.6k tokensUpdated 5 mo ago
    Testing & QAAuto-check passed
  • Supercov

    supercorp-ai/supercov

    Measures test coverage and code quality in a repository with the supercov CLI, and turns what it finds into small, focused tests or fixes.

    151 GitHub starsUsed in 1 repo~415 tokens
    Testing & QAAuto-check passed
  • Optest

    PyLops/pylops

    Raise a PyLops operator's test coverage above a threshold (default 90%) by adding or modifying tests.

    539 GitHub stars~729 tokensUpdated yesterday
    Testing & QAAuto-check passed
  • Review Op

    CVCUDA/CV-CUDA

    Review a CV-CUDA operator end-to-end (support / test / bench / docs coverage).

    2.7k GitHub stars~481 tokensUpdated 23 days ago
    Testing & QAAuto-check passed
  • Supercov Security

    supercorp-ai/supercov

    Scans a repository's source for security vulnerabilities with the supercov CLI, pointing to the line of each finding and mapping it to CWE classes.

    151 GitHub starsUsed in 1 repo~236 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

Works with

Categories

Questions about Analyzing Test Coverage

What does Analyzing Test Coverage do?

Analyze code coverage metrics and identify untested code paths. Analyzing Test Coverage is an agent skill from jeremylongshore/tons-of-skills-marketplace. Analyze code coverage metrics and identify untested code paths.

When should I use Analyzing Test Coverage?

Analyzing Test Coverage fits situations like: analyzing untested code; with phrases like analyze coverage; check test coverage; find untested code.

How do I install Analyzing Test Coverage in Claude Code?

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

How do I install Analyzing Test Coverage in Codex?

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

Can I use Analyzing Test Coverage 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 analyzing-test-coverage -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/analyzing-test-coverage, .gemini/skills/analyzing-test-coverage, .github/skills/analyzing-test-coverage and .opencode/skills/analyzing-test-coverage in your project.

What does Analyzing Test Coverage need to run?

Going by SKILL.md and its folder, Analyzing Test Coverage needs Python for the scripts in its folder and the command-line tools its instructions call (go, node, python3, npx and pytest). Our summary lists: Python 3; Node.js. Its frontmatter pre-approves these tools: Read, Write, Edit, Grep, Glob, Bash(test:coverage-*). Compatibility (from SKILL.md): Designed for Claude Code.

Does Analyzing Test Coverage access the network?

SKILL.md names 6 domains. As links in the text: istanbul.js.org, github.com, coverage.readthedocs.io, jacoco.org, go.dev and testing.googleblog.com. This is read from the text; nothing was executed.

Is Analyzing Test Coverage 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 Analyzing Test Coverage use?

Analyzing Test Coverage 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 Analyzing Test Coverage use?

About 1.4k tokens (SKILL.md is roughly 5.8k 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 17 tokens, read only when the agent opens those files.

What are the alternatives to Analyzing Test Coverage?

Skills that share tags, products or a category with Analyzing Test Coverage: Find Untested Sources (dotnet/skills, 5.6k stars), Test Coverage Review (areed1192/finance-news-aggregator, 149 stars), Supercov (supercorp-ai/supercov, 151 stars) and Optest (PyLops/pylops, 539 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Analyzing Test Coverage?

jeremylongshore (a GitHub user) maintains it in jeremylongshore/tons-of-skills-marketplace, which has 2,825 GitHub stars. The repository holds 3,342 skills in this directory. The repository was last updated on October 9, 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.