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

Agent skill

Check Test Coverage

by r3bl-org in r3bl-org/r3bl-open-core

Audit and verify test coverage for a specific file or module, ensuring all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test…

Apache-2.0Auto-check passedTesting & QA

Install Check Test Coverage

skills CLI
$ npx skills add r3bl-org/r3bl-open-core --skill check-test-coverage -a claude-code

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

GitHub CLI
$ gh skill install r3bl-org/r3bl-open-core check-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/r3bl-org/r3bl-open-core.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/check-test-coverage .claude/skills/check-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
check-test-coverage
GitHub stars
485
Token cost
~1.7k tokens
SKILL.md length
633 words
Files
2
Skills in repo
25
Repo updated
First seen
Licence
Apache-2.0

At a glance

Audit and verify test coverage for a specific file or module, ensuring all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test…

  • Works in 5 steps: Inspect the Target File → Classify Code Components (Custom Logic… → Discover All Test Locations → …
  • Tasks that involve Test coverage
  • SKILL.md covers When to Use, Core Philosophy: Zero Test…, 5-Step Audit Workflow and Detailed Classification Guide, plus 1 more section
  • Calls cargo

What it does

Check Test Coverage is an agent skill from r3bl-org/r3bl-open-core. Audit and verify test coverage for a specific file or module, ensuring all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test bloat (never testing std, third-party crates, or macro-derived boilerplate). Use via /check-test-coverage <filename.

Its SKILL.md is about 1.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 1 other file (for example `examples.md`).

It sits in Testing & QA, covering Test coverage and Project scaffolding. The repository describes itself as: TUI framework and developer productivity apps in Rust 🦀. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Test coverage
  • Tasks that involve Project scaffolding

Example prompts

  • “/check-test-coverage”

Workflow steps

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

  1. Inspect the Target File
  2. Classify Code Components (Custom Logic vs Upstream/Derives)
  3. Discover All Test Locations
  4. Construct the Branch & Boundary Matrix
  5. Deliver Actionable Verdict & Recommendations

What it can do on your machine

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

    Shell commands in SKILL.md call:

    • cargo

    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

Check Test Coverage loads about 1.7k tokens when it runs. Until then it costs about 83 tokens; SKILL.md has 633 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~83
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k

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 r3bl-org/r3bl-open-core at commit 89db352, republished under its Apache-2.0 licence (© r3bl-org). 633 words, ~1,747 tokens.

Download SKILL.mdSave it as .claude/skills/check-test-coverage/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
check-test-coverage
description
Audit and verify test coverage for a specific file or module, ensuring all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test bloat (never testing std, third-party crates, or macro-derived boilerplate). Use via /check-test-coverage <filename>.

// Copyright (c) 2026 R3BL LLC. Licensed under Apache License, Version 2.0.

Skill: check-test-coverage

Audit and verify test coverage for a specific file or module. Ensure all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test bloat (never testing std, third-party crates, or macro-derived boilerplate).

When to Use

  • When invoked via the /check-test-coverage <file_path> command.
  • When reviewing a file before creating a commit or finalizing a task.
  • When evaluating whether a newly added or modified file has sufficient test coverage.
  • When auditing existing test suites to identify missing custom logic tests or remove redundant test bloat.

Core Philosophy: Zero Test Bloat ("Test OUR Code, Not Dependencies")

Traditional "code coverage" tools blindly count lines or instructions executed, encouraging developers to write low-signal tests for boilerplate, compiler derives, and third-party crates.

In this codebase, test quality is measured by branch-targeted verification of OUR custom logic:

  1. Test OUR Code Exclusively:
    • Tests must target the unique execution paths, custom algorithms, match branches, state transitions, conversion traits (From, TryFrom), and error conditions written by us.
  2. Never Test Dependencies or Compiler Derives:
    • Never write tests that merely assert standard library behavior (std::collections::HashMap, std::env, std::ffi::OsString).
    • Never write unit tests for standard compiler derives (#[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]).
    • Never write unit tests for third-party derive macros (such as #[derive(Display, EnumString)] with #[strum(serialize_all = "lowercase")] or clap::ValueEnum).
  3. High Signal, Low Maintenance Overhead:
    • Redundant tests slow down cargo test and check.fish iteration cycles.
    • Redundant test failures during refactoring obscure real bugs and create maintenance friction.

5-Step Audit Workflow

When running /check-test-coverage <path>, follow these five steps systematically:

Step 1: Inspect the Target File

Read the entire target file using view_file or AST navigation (rust_analyzer_symbols). Catalog all items:

  • Public and private functions (fn)
  • Structs and Enums
  • Derived traits vs custom trait implementations (impl Trait for Type)
  • Match expressions, if let blocks, and conditionals
  • Error handling paths (Result, Option, unwrap_or_else, unreachable!)
Step 2: Classify Code Components (Custom Logic vs Upstream/Derives)

Separate items into two categories:

CategoryWhat it includesTesting Requirement
OUR Custom LogicCustom functions, custom parsers/formatters, manual trait impls (From, TryFrom, Display), business logic, state machines, boundary checks, error branchesMust be covered with targeted test cases (1 test per branch/boundary)
Upstream / Derives#[derive(Default, Clone, Copy, PartialEq, Eq, Debug)], strum macro attributes, clap derive attributes, standard library forwardsDo NOT test (testing these is test bloat)
Step 3: Discover All Test Locations

Locate all test functions covering the file:

  1. Inline unit tests: mod tests inside the file itself.
  2. Adjacent unit test modules: E.g., unit_tests.rs or mod.rs test modules in the same directory.
  3. Integration and conformance tests: E.g., tests/, conformance_tests/, or crate-level integration suites.
Show full SKILL.md (266 more words)Show less
Step 4: Construct the Branch & Boundary Matrix

Create a structured audit table mapping each piece of custom logic to its test coverage:

markdown
| Target Symbol / Branch | Test Function | Classification | Status |
| :--- | :--- | :--- | :--- |
| `InputKind::from((Some, None))` | `test_tuple_to_input_kind_file` | Custom `From` logic | Covered |
| `InputKind::from((None, Some))` | `test_tuple_to_input_kind_command` | Custom `From` logic | Covered |
| `BaseEnv::default()` | — | Compiler `#[derive(Default)]` | Skipped (Dependency / Derive) |
| `OutputFormat` strum display | — | Strum macro derive | Skipped (Dependency / Derive) |
Step 5: Deliver Actionable Verdict & Recommendations

Provide a concise, high-signal report:

  1. Verdict: Explicitly state whether coverage is Sufficient or Insufficient.
  2. Branch Coverage Breakdown: Show which custom logic branches are covered vs missing.
  3. Zero Bloat Verification: Confirm no tests are testing standard library or third-party macros.
  4. Concrete Test Code: If any custom branches are missing, provide exact, ready-to-use unit test snippets.

Detailed Classification Guide

What MUST Be Tested (Our Custom Logic)
  • Manual Trait Implementations:
    rust
    // MUST TEST: Custom conversion logic with 2 branches
impl From<(&Option<PathBuf>, &Option<String>)> for InputKind {
    fn from(tuple: (&Option<PathBuf>, &Option<String>)) -> InputKind {
        match tuple {
            (Some(file), None) => InputKind::File(file.clone()),
            (None, Some(cmd)) => InputKind::InlineCommand(cmd.clone()),
            _ => unreachable!(),
        }
    }
}
  • Custom Parsing & Formatting Logic:
    • Regex parsing, state machines, ANSI code builders, diff calculators.
  • Boundary & Overflow Checks:
    • Off-by-one boundary cases, index-overflow conditions (see check-bounds-safety skill).
  • Error & Fallback Branches:
    • Err returns, fallback defaults when inputs are malformed.
What MUST NOT Be Tested (Test Bloat)
  • Standard Derives:
    rust
    // DO NOT TEST: Testing BaseEnv::default() tests the Rust compiler derive macro.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub enum BaseEnv {
    #[default]
    Inherit,
    Explicit(EnvMap),
}
  • Third-Party Macro Derives:
    rust
    // DO NOT TEST: Testing .to_string() tests strum's macro generator.
#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum, Display, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum OutputFormat {
    Fish,
    Powershell,
    Json,
    Dotenv,
}
  • Standard Library Collections / Types:
    • Do NOT test whether HashMap::insert stores a value or whether PathBuf::from works.
  • organize-tests: Test directory taxonomy, isolation patterns, and zero test-bloat directive.
  • check-bounds-safety: Type-safe index and length bounds verification.
  • check-code-quality: Full quality verification suite (./check.fish --full).

© r3bl-org, Apache-2.0. 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 1 other file in .agents/skills/check-test-coverage of r3bl-org/r3bl-open-core.

  • SKILL.md
  • examples.md

Open the folder on GitHubat commit 89db352

Compare with similar skills

Check 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.

Check Test Coverage compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Check Test Coverage this skillr3bl-org/r3bl-open-core485—~1.7kAutomated safety check: PassApache-2.0
Senior QAalirezarezvani/claude-skills28k1 repos~2.1kAutomated safety check: PassMIT
Score Harnessruvnet/metaharness690—~613Automated safety check: PassMIT
Requirementsrizsotto/Bear6.5k—~2kAutomated safety check: PassGPL-3.0
Crap Analysisardalis/RiverBooks1352 repos~3.4kAutomated safety check: PassNone
Code Coverages3s-project/s3s311—~789Automated safety check: PassApache-2.0

Similar skills

  • Senior QA

    alirezarezvani/claude-skills

    Generates unit tests, integration tests, and E2E tests for React/Next.js applications.

    28k GitHub starsUsed in 1 repo~2.1k tokens
    Testing & QAAuto-check passed

  • Score Harness

    ruvnet/metaharness

    5-dimension scorecard (0-100, grade A/B/C/F) for a scaffolded harness.

    690 GitHub stars~613 tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Requirements

    rizsotto/Bear

    Write, modify, or review a requirement file under docs/requirements -- pick the single owning file, keep the text contract-only, name IDs so they need no explanation, and verify cross-references and…

    6.5k GitHub stars~2k tokensUpdated yesterday
    Testing & QAAuto-check passed

  • Crap Analysis

    ardalis/RiverBooks

    Analyze code coverage and CRAP (Change Risk Anti-Patterns) scores to identify high-risk code.

    135 GitHub starsUsed in 2 repos~3.4k tokens
    Testing & QAAuto-check passed

  • Code Coverage

    s3s-project/s3s

    Measure and grow the line coverage of the s3s crate. An agent skill from s3s-project/s3s.

    311 GitHub stars~789 tokensUpdated today
    Testing & QAAuto-check passed

  • Veomni Patchgen Model

    ByteDance-Seed/VeOmni

    Author or refresh a VeOmni model's patchgen-generated modeling under generated/ — GPU and/or NPU config, dense or MoE, text / VLM / Omni.

    2.2k GitHub stars~9.6k tokensUpdated today
    Testing & QAAuto-check passed

More from r3bl-org/r3bl-open-core

All 25 skills in this repo

  • Analyze Log Files

    r3bl-org/r3bl-open-core

    Analyze log files by stripping ANSI escape sequences first. An agent skill from r3bl-org/r3bl-open-core.

    485 GitHub stars~632 tokensUpdated today
    Auto-check: notes

  • Analyze Performance

    r3bl-org/r3bl-open-core

    Establish performance baselines and detect regressions using flamegraph analysis.

    485 GitHub stars~2k tokensUpdated today
    Auto-check passed

  • Check Bounds Safety

    r3bl-org/r3bl-open-core

    Apply type-safe bounds checking patterns using VPIndex/VPLength types instead of usize.

    485 GitHub stars~4.1k tokensUpdated today
    Auto-check passed

  • Release Crate

    r3bl-org/r3bl-open-core

    Publish a crate release to crates.io with changelog, standalone release notes, git tag, and GitHub release.

    485 GitHub stars~2.4k tokensUpdated today
    Auto-check passed

  • Organize Modules

    r3bl-org/r3bl-open-core

    Apply private modules with public re-exports (barrel export) pattern for clean API design.

    485 GitHub stars~5.8k tokensUpdated today
    Auto-check passed

  • Check Code Quality

    r3bl-org/r3bl-open-core

    Run comprehensive Rust code quality checks including compilation, linting, documentation, and tests.

    485 GitHub stars~3.8k tokensUpdated today
    Auto-check passed

Categories

Questions about Check Test Coverage

What does Check Test Coverage do?

Audit and verify test coverage for a specific file or module, ensuring all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test…. Check Test Coverage is an agent skill from r3bl-org/r3bl-open-core. Audit and verify test coverage for a specific file or module, ensuring all custom logic branches, state transitions, and boundary conditions are covered while strictly eliminating dependency test bloat (never testing std, third-party crates, or macro-derived boilerplate).

When should I use Check Test Coverage?

Check Test Coverage fits situations like: tasks that involve Test coverage; tasks that involve Project scaffolding.

How do I install Check Test Coverage in Claude Code?

Run `npx skills add r3bl-org/r3bl-open-core --skill check-test-coverage -a claude-code`. Or copy the skill folder (.agents/skills/check-test-coverage in r3bl-org/r3bl-open-core) into .claude/skills/check-test-coverage in your project. Claude Code loads it when a task matches its description.

How do I install Check Test Coverage in Codex?

Run `npx skills add r3bl-org/r3bl-open-core --skill check-test-coverage -a codex`. Or copy the skill folder (.agents/skills/check-test-coverage in r3bl-org/r3bl-open-core) into .agents/skills/check-test-coverage in your project. Codex loads it when a task matches its description.

Can I use Check 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 r3bl-org/r3bl-open-core --skill check-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/check-test-coverage, .gemini/skills/check-test-coverage, .github/skills/check-test-coverage and .opencode/skills/check-test-coverage in your project.

What does Check Test Coverage need to run?

Going by SKILL.md and its folder, Check Test Coverage needs the command-line tools its instructions call (cargo).

Does Check Test Coverage 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 Check 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. Review the folder before installing.

What licence does Check Test Coverage use?

Check Test Coverage is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Check Test Coverage use?

About 1.7k tokens (SKILL.md is roughly 7k 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 Check Test Coverage?

Skills that share tags, products or a category with Check Test Coverage: Senior QA (alirezarezvani/claude-skills, 28k stars), Score Harness (ruvnet/metaharness, 690 stars), Requirements (rizsotto/Bear, 6.5k stars) and Crap Analysis (ardalis/RiverBooks, 135 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Check Test Coverage?

r3bl-org (a GitHub organization) maintains it in r3bl-org/r3bl-open-core, which has 485 GitHub stars. The repository holds 25 skills in this directory. The repository was last updated on October 8, 2026.

Source: r3bl-org/r3bl-open-core on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.