Skip to content
Skills Library
Programming · Review & audit

test-coverage-analyzer

/test-coverage-analyzer

Analyzes test coverage reports, identifies gaps, and recommends priority areas for testing. Use when reviewing coverage, finding untested code, or planning test improvements.

Licence
MIT
Last repository change
27.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Analyzes test coverage reports, identifies gaps, and recommends priority areas for testing. Use when reviewing coverage, finding untested code, or planning test improvements.

Original author description

Analyzes test coverage reports, identifies gaps, and recommends priority areas for testing. Use when reviewing coverage, finding untested code, or planning test improvements.

How it works

  1. Quick Start
  2. Instructions
  3. Common Patterns
  4. Advanced
Original SKILL.md headings · 139 lines, 370 words
SKILL.md preview
---
name: test-coverage-analyzer
description: Analyzes test coverage reports, identifies gaps, and recommends priority areas for testing. Use when reviewing coverage, finding untested code, or planning test improvements.
---

# Test Coverage Analyzer

Analyze test coverage and identify testing gaps.

## Quick Start

Run coverage and analyze results:
```bash
# JavaScript/TypeScript
npm test -- --coverage

# Python
pytest --cov=src --cov-report=term-missing

# Go
go test -cover ./...
```

## Instructions

### Step 1: Generate Coverage Report

**JavaScript/TypeScript (Jest)**:
```bash
npm test -- --coverage --coverageReporters=text --coverageReporters=lcov
```

**JavaScript/TypeScript (Vitest)**:
```bash
vitest run --coverage
```

**Python (pytest)**:
```bash
pytest --cov=src --cov-report=html --cov-report=term-missing
```

**Go**:
```bash
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out
```

### Step 2: Analyze Coverage Metrics

Review these key metrics:
- **Line coverage**: Percentage of lines executed
- **Branch coverage**: Percentage of conditional branches tested
- **Function coverage**: Percentage of functions called
- **Statement coverage**: Percentage of statements executed

**Target thresholds**:
- Critical code: 80%+ coverage
- Standard code: 60%+ coverage
- UI/Config: 40%+ coverage

### Step 3: Identify Gaps

Look for:
- **Uncovered functions**: Functions with 0% coverage
- **Partial coverage**: Functions with <50% coverage
- **Missing branches**: Untested if/else paths
- **Error paths**: Untested catch blocks
- **Edge cases**: Boundary conditions not tested

### Step 4: Prioritize Testing

**High Priority** (test first):
- Business logic with 0% coverage
- Security-critical functions
- Payment/transaction code
- Data validation logic
- Error handling paths

**Medium Priority** (test next):
- API endpoints
- Database operations
- Utility functions
- Configuration logic

**Low Priority** (test if time permits):
- Simple getters/setters
- UI presentation logic
- Type definitions
- Generated code

### Step 5: Create Action Plan

For each gap:
1. Identify the untested code
2. Determine test type needed (unit/integration/e2e)
3. Estimate effort (small/medium/large)
4. Assign priority (high/medium/low)
5. Create test implementation tasks

## Common Patterns

**Pattern: Find untested files**
```bash
# Jest
npm test -- --coverage --collectCoverageFrom='src/**/*.{js,ts}' --coverageThreshold='{"global":{"lines":0}}'

# pytest
pytest --cov=src --cov-report=term-missing | grep "0%"
```

**Pattern: Check specific module**
```bash
# Jest
npm test -- path/to/module --coverage

# pytest
pytest tests/test_module.py --cov=src.module --cov-report=term-missing
```

**Pattern: Enforce coverage thresholds**
```json
// package.json (Jest)
{
  "jest": {
    "coverageThreshold": {
      "global": {
        "branches": 70,
        "functions": 70,
        "lines": 70,
        "statements": 70
      }
    }
  }
}
```

## Advanced

For detailed information, see:
- [Coverage Tools](reference/coverage-tools.md) - Tool-specific configuration and usage
- [Testing Patterns](reference/patterns.md) - Common testing patterns and best practices
Files in this package (3)
  • SKILL.md 3 KB
  • reference/coverage-tools.md 6 KB
  • reference/patterns.md 9 KB

Versions

RepositoryScoreLicence
This page · armanzeroeight/fastagent-plugins100MIT
MuhammadUsmanGM/Skills_Assignment90MIT

Database snapshot: 13.11.2026 · package version ae6fda34db72 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95coverage-analyzer
    Analyze test coverage with detailed metrics, identify gaps, and generate comprehensive reports. Use when measuring code coverage, finding untested code, or validating coverage thresholds.
  • 100coverage-report-analyzer
    Analyze coverage report analyzer operations. Auto-activating skill for Test Automation. Triggers on: coverage report analyzer, coverage report analyzer Part of the Test Automation skill category. Use when analyzing or auditing coverage report analyzer. Trigger with phrases like…
  • 100analyzing-test-coverage
    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".
  • 100analyzing-test-coverage
    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".
  • 100test-coverage-improver
    Analyze test coverage gaps and generate tests to improve coverage. Use when improving test coverage, finding untested code, or writing missing tests.
  • 100coverage-analyzer
    Automatically analyze test coverage when user asks which code is tested, mentions coverage gaps, or shows code asking about testing. Identifies untested code paths and suggests test additions. Invoke when user asks "what's not tested?", "coverage", "untested code", or "which tests are missing?".

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.