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

Agent skill

Check Patch Coverage

by fullsend-ai in fullsend-ai/fullsend

Verify approximate Go patch coverage meets the repo's Codecov patch gate: 80% target, 75% enforced floor (5% threshold).

Apache-2.0Auto-check passedTesting & QA

Install Check Patch Coverage

skills CLI
$ npx skills add fullsend-ai/fullsend --skill check-patch-coverage -a claude-code

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

GitHub CLI
$ gh skill install fullsend-ai/fullsend check-patch-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/fullsend-ai/fullsend.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/check-patch-coverage .claude/skills/check-patch-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-patch-coverage
GitHub stars
147
Token cost
~1.4k tokens
SKILL.md length
634 words
Files
1
Skills in repo
15
Repo updated
First seen
Licence
Apache-2.0

At a glance

Verify approximate Go patch coverage meets the repo's Codecov patch gate: 80% target, 75% enforced floor (5% threshold).

  • Works in 7 steps: Identify changed production files → Determine affected packages → Check for packages with no test files → …
  • Tasks that involve Test coverage
  • SKILL.md covers When to use, When to skip, Procedure and Understanding the approximation, plus 1 more section
  • Calls go and git

What it does

Check Patch Coverage is an agent skill from fullsend-ai/fullsend. Verify approximate Go patch coverage meets the repo's Codecov patch gate: 80% target, 75% enforced floor (5% threshold). Use after writing or updating Go production code — before committing — to catch coverage gaps that would fail the codecov/patch status check.

Its SKILL.md is about 1.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 Test coverage. The repository describes itself as: On the path to fully autonomous agentic engineering. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Test coverage

Example prompts

  • “/check-patch-coverage”

Workflow steps

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

  1. Identify changed production files
  2. Determine affected packages
  3. Check for packages with no test files
  4. Run tests with a cover profile
  5. Check per-function coverage on changed files
  6. Assess against the 80% target (75% floor)
  7. Visual inspection (optional, for complex cases)

What it can do on your machine

Read from SKILL.md and the folder at commit 0d999c2. 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:

    • go
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    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 Patch Coverage loads about 1.4k tokens when it runs. Until then it costs about 71 tokens; SKILL.md has 634 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~71
When it runs · the whole SKILL.md, loaded when a task matches
~1.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 fullsend-ai/fullsend at commit 0d999c2, republished under its Apache-2.0 licence (© fullsend-ai). 634 words, ~1,375 tokens.

Download SKILL.mdSave it as .claude/skills/check-patch-coverage/SKILL.md (or your agent's skills folder).
name
check-patch-coverage
description
Verify approximate Go patch coverage meets the repo's Codecov patch gate: 80% target, 75% enforced floor (5% threshold). Use after writing or updating Go production code — before committing — to catch coverage gaps that would fail the codecov/patch status check.

Check Patch Coverage

Verify that new or changed Go production code meets the Codecov patch coverage gate in .codecov.yml before committing. The target is 80% with a 5% threshold, so codecov/patch passes at ≥ 75%. Codecov PR comments still mark ✗ below 80% even when that status check is green. Target 80% locally to stay above both signals.

When to use

  • After implementing or modifying Go production code under cmd/ or internal/ (files that are not _test.go).
  • After adding tests for new code — to confirm coverage is sufficient.
  • When the fix agent is addressing a coverage-related failure.

When to skip

  • Test-only changes (no production .go files modified).
  • Documentation, config, or generated-code-only changes.
  • Files listed in .codecov.yml ignore: — these are excluded from coverage enforcement.

Procedure

1. Identify changed production files

Determine which non-test Go files you changed relative to the target branch. Stage new files first (git add) — git diff --name-only only sees tracked or staged files, so an unstaged new file would be invisible and the check would silently skip it.

bash
CHANGED_GO=$(git diff --name-only main -- '*.go' | grep -v '_test.go')
echo "$CHANGED_GO"

If the list is empty, patch coverage does not apply — stop here.

2. Determine affected packages
bash
PKGS=$(echo "$CHANGED_GO" | xargs -I{} dirname {} | sort -u | sed 's|^|./|')
echo "$PKGS"
3. Check for packages with no test files

Before running coverage, check whether each affected package actually contains test files. Go's go test -coverprofile only attributes coverage to the package under test — a package with zero _test.go files produces no coverage data at all, and Codecov will report 0% for every changed line.

bash
MISSING_TESTS=""
for pkg_dir in $PKGS; do
  dir="${pkg_dir#./}"
  if ! ls "$dir"/*_test.go >/dev/null 2>&1; then
    echo "⚠  Package $dir has no test files — codecov/patch will report 0% coverage."
    echo "   Create a _test.go file with direct unit tests for new/modified exported functions."
    MISSING_TESTS="$MISSING_TESTS $dir"
  fi
done

If any packages were flagged: stop and create test files in those packages before continuing. The 75% enforced floor cannot be met when no coverage profile is generated for a package. Treat this as a coverage gap regardless of the threshold — add at least one _test.go file with direct unit tests for the new or modified exported functions, then re-run from step 1.

4. Run tests with a cover profile
bash
go test -coverprofile=coverage.out -count=1 $PKGS

If tests fail, fix them first — coverage is meaningless on broken code.

5. Check per-function coverage on changed files

For each changed file, inspect coverage:

bash
for f in $CHANGED_GO; do
  echo "=== $f ==="
  go tool cover -func=coverage.out | grep "$f" \
    || echo "⚠  No coverage data for $f — this file's package may lack test files. See step 3."
done

If any file shows no coverage data, go back to step 3 and verify the package has test files. A (no coverage data) result means Codecov will report 0% for that file's changed lines.

Each output line shows file:line: function coverage%.

Show full SKILL.md (260 more words)Show less
6. Assess against the 80% target (75% floor)

Look at the functions you added or modified:

  • All functions ≥ 80%: Coverage is sufficient. Proceed to commit.
  • Some functions below 80%: Add or extend _test.go files to cover the missing lines. Focus on:
    • New functions you added (these must be tested)
    • Modified functions where you added new branches or error paths
    • Functions at 0% that contain logic (not just simple getters/setters)

After adding tests, re-run from step 4 and re-check.

7. Visual inspection (optional, for complex cases)

If function-level coverage is borderline or the function has complex branching:

bash
go tool cover -html=coverage.out

This opens an HTML view showing exactly which lines are covered (green) and which are not (red). Use this to target your test additions.

Understanding the approximation

This procedure approximates Codecov's line-level patch coverage using Go's function-level coverage (go tool cover -func). The local check is coarser — Codecov counts individual lines in the diff, while go tool cover -func reports per-function percentages.

The codecov/patch status check enforces 75% (80% target minus the 5% threshold in .codecov.yml). Codecov PR comments still mark ✗ when coverage is below the 80% target, even if the status check is green. Aim for ≥ 80% on touched functions so both the comment glyph and the status check stay consistent, and to cover the approximation gap between function-level and line-level metrics.

Thresholds reference

From .codecov.yml:

  • Patch coverage target: 80%
  • Enforced floor (codecov/patch status check): 75% (5% threshold)
  • Codecov PR comment glyph: ✗ below the 80% target, even if the status check passes
  • Project coverage: must not drop more than 1% below base branch

© fullsend-ai, 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

Just SKILL.md in skills/check-patch-coverage of fullsend-ai/fullsend.

Open the folder on GitHubat commit 0d999c2

Compare with similar skills

Check Patch 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 Patch Coverage compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Check Patch Coverage this skillfullsend-ai/fullsend147—~1.4kAutomated safety check: PassApache-2.0
Requirementsrizsotto/Bear6.5k—~2kAutomated safety check: PassGPL-3.0
Crap Analysisardalis/RiverBooks1342 repos~3.4kAutomated safety check: PassNone
Code Coverages3s-project/s3s311—~789Automated safety check: PassApache-2.0
Project Statusbactopia/bactopia522—~787Automated safety check: PassMIT
Check Coverageldayton/Dippy243—~403Automated safety check: PassMIT

Similar skills

  • 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 today
    Testing & QAAuto-check passed

  • Crap Analysis

    ardalis/RiverBooks

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

    134 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

  • Project Status

    bactopia/bactopia

    Show a live snapshot of the Bactopia project state — component counts, GroovyDoc coverage, nf-test coverage, and structural issues.

    522 GitHub stars~787 tokensUpdated 2 mo ago
    Testing & QAAuto-check passed

  • Check Coverage

    ldayton/Dippy

    Ensure comprehensive test coverage for a CLI handler. An agent skill from ldayton/Dippy.

    243 GitHub stars~403 tokensUpdated 3 mo ago
    Testing & QAAuto-check passed

  • Guarding Destructive Operations

    kajisho5/ffmpeg-skill

    Add and review preconditions on operations that delete, overwrite, rewrite history, or resolve a caller-supplied name to a filesystem path — refusing instead of warning, placing the guard ahead of…

    1.9k GitHub stars~2.6k tokensUpdated 2 days ago
    Testing & QAAuto-check passed

More from fullsend-ai/fullsend

All 15 skills in this repo

  • Cutting Releases

    fullsend-ai/fullsend

    A skill your agent uses when the user wants to tag a release, cut a release candidate, or ship a new version.

    147 GitHub stars~3.5k tokensUpdated today
    Auto-check passed

  • Topissues

    fullsend-ai/fullsend

    Build a merged RICE priority table: top unassigned backlog issues plus issues assigned to the current user.

    147 GitHub stars~523 tokensUpdated today
    Auto-check passed

  • User Forum Whats New

    fullsend-ai/fullsend

    A skill your agent uses when preparing the Fullsend user forum "What's New" agenda, a Tuesday-to-Tuesday recap, forum-host talk-track notes, or copy-paste HTML of shipped changes for users.

    147 GitHub stars~4k tokensUpdated today
    Auto-check passed

  • Adr Corner

    fullsend-ai/fullsend

    Find open GitHub pull requests that add or change Architecture Decision Records and report attribution, summaries, discussion points, and dates.

    147 GitHub stars~654 tokensUpdated today
    Auto-check passed

  • Nextwork

    fullsend-ai/fullsend

    Build a readiness-oriented queue of open issues/PRs — assigned work plus their open GitHub blockers — and recommend the next action for each.

    147 GitHub stars~5.3k tokensUpdated today
    Auto-check passed

  • Analyze Transcript

    fullsend-ai/fullsend

    Analyze fullsend agent run transcripts from GitHub Actions artifacts.

    147 GitHub stars~2.7k tokensUpdated today
    Auto-check passed

Categories

Questions about Check Patch Coverage

What does Check Patch Coverage do?

Verify approximate Go patch coverage meets the repo's Codecov patch gate: 80% target, 75% enforced floor (5% threshold). Check Patch Coverage is an agent skill from fullsend-ai/fullsend. Verify approximate Go patch coverage meets the repo's Codecov patch gate: 80% target, 75% enforced floor (5% threshold).

When should I use Check Patch Coverage?

Check Patch Coverage fits situations like: tasks that involve Test coverage.

How do I install Check Patch Coverage in Claude Code?

Run `npx skills add fullsend-ai/fullsend --skill check-patch-coverage -a claude-code`. Or copy the skill folder (skills/check-patch-coverage in fullsend-ai/fullsend) into .claude/skills/check-patch-coverage in your project. Claude Code loads it when a task matches its description.

How do I install Check Patch Coverage in Codex?

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

Can I use Check Patch 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 fullsend-ai/fullsend --skill check-patch-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-patch-coverage, .gemini/skills/check-patch-coverage, .github/skills/check-patch-coverage and .opencode/skills/check-patch-coverage in your project.

What does Check Patch Coverage need to run?

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

Does Check Patch Coverage access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Check Patch 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 Patch Coverage use?

Check Patch 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 Patch Coverage use?

About 1.4k tokens (SKILL.md is roughly 5.5k 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 Patch Coverage?

Skills that share tags, products or a category with Check Patch Coverage: Requirements (rizsotto/Bear, 6.5k stars), Crap Analysis (ardalis/RiverBooks, 134 stars), Code Coverage (s3s-project/s3s, 311 stars) and Project Status (bactopia/bactopia, 522 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Check Patch Coverage?

fullsend-ai (a GitHub organization) maintains it in fullsend-ai/fullsend, which has 147 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on October 7, 2026.

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