菜单
Define a meaningful test coverage strategy beyond line counts. Outputs coverage goals by risk tier, measurement approach, gap analysis, and improvement roadmap.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/kalilurrahman/kr-claudiator-skills --skill test-coverage-strategy命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
基于 SOC 职业分类
| name | test-coverage-strategy |
| description | Define a meaningful test coverage strategy beyond line counts. Outputs coverage goals by risk tier, measurement approach, gap analysis, and improvement roadmap. |
| argument-hint | ["codebase size","risk profile","current coverage","CI tooling","team maturity"] |
| allowed-tools | Read, Write, Bash |
Coverage percentage is a floor, not a goal. 80% coverage with trivial tests is worse than 60% coverage with excellent tests of the riskiest code. A meaningful coverage strategy defines what to cover, how much, and how to measure coverage quality — not just quantity.
LINE COVERAGE: % of lines executed
Weakest measure — a line can execute without being tested correctly
BRANCH COVERAGE: % of if/else branches taken
Better — tests both true and false paths
CONDITION COVERAGE: Each boolean sub-expression true and false
Strongest for complex boolean logic
MUTATION COVERAGE: % of injected bugs (mutations) caught by tests
Measures test quality, not just execution
Target: >60% mutation score
PATH COVERAGE: All unique execution paths
Combinatorially explosive — impractical for complex code
# Coverage targets by code risk tier
COVERAGE_TARGETS = {
"tier_1_critical": {
"examples": ["payment processing", "auth", ],
: ,
: ,
: ,
: ,
},
: {
: [, , ],
: ,
: ,
: ,
: ,
},
: {
: [, , ],
: ,
: ,
: ,
: ,
},
: {
: [, , ],
: ,
: ,
: ,
: ,
},
}
# pytest: setup.cfg
[coverage:run]
source = src/
branch = True
omit =
*/migrations/*
*/tests/*
*/conftest.py
src/generated/*
src/config/settings.py
[coverage:report]
show_missing = True
fail_under = 75 # Global floor
exclude_lines =
pragma: no cover
def __repr__
raise NotImplementedError
if TYPE_CHECKING:
@abstract
// Jest: jest.config.js
module.exports = {
collectCoverageFrom: [
"src/**/*.{js,ts,jsx,tsx}",
"!src/**/*.d.ts",
"!src/**/*.stories.tsx",
"!src/generated/**",
],
coverageThresholds: {
global: {
lines: 75,
branches: 65,
functions: 75,
statements: 75,
},
// Higher threshold for critical paths
"./src/payments/**": {
lines: 95,
branches: 90,
},
},
};
# Find uncovered lines in critical paths
coverage run -m pytest tests/
coverage report --include="src/payments/*" --show-missing
# Identify riskiest uncovered code (high complexity + low coverage)
pip install radon
radon cc src/ -s -n B | head -20 # High complexity functions
coverage report --include="src/payments/*" --skip-covered | head -30 # Uncovered
# Mutation testing (Python)
pip install mutmut
mutmut run --paths-to-mutate=src/payments/
mutmut results
# Survived mutations = tests that don't catch bugs
# .github/workflows/coverage.yml
- name: Run tests with coverage
run: |
pytest --cov=src --cov-report=xml --cov-report=term-missing
# Check critical path coverage separately
python3 -c "
import xml.etree.ElementTree as ET
tree = ET.parse('coverage.xml')
for pkg in tree.findall('.//package[@name="src/payments"]'):
line_rate = float(pkg.attrib['line-rate'])
if line_rate < 0.95:
print(f'FAIL: payments coverage {line_rate:.1%} < 95%')
exit(1)
print('Payment coverage OK')
"
| Anti-Pattern | Problem | Fix |
|---|---|---|
| 100% coverage target | Trivial tests added for coverage; masks quality | Risk-tiered targets; quality over quantity |
| Line coverage only | Branches untested; bugs hide in else clauses | Require branch coverage for tier 1-2 |
| Coverage without mutation testing | 100% line coverage can catch 0% of bugs | Mutation score on critical paths |
| Same threshold for all code | Generated code and payment code treated equally | Tiered targets by risk |
| Coverage-driven test writing | Tests written to hit lines, not verify behaviour | Write tests for behaviour; coverage is a by-product |
The sections below extend this skill into a complete operating playbook so it can run end-to-end inside Claude Code, CoWork, or any agentic tool without further prompting. Pull only the sections you need for a given engagement.
Before producing any output, the skill confirms:
If any of these are missing, the skill asks targeted clarifying questions before generating output. It never invents constraints the user did not state.
The canonical workflow for Test Coverage Strategy runs in five stages. Each stage has an explicit exit criterion so the skill knows when to advance.
Stage 1 — Frame. Restate the problem in one paragraph. Name the decision, the deadline, the stakeholders, and the success metric. Surface assumptions explicitly so they can be challenged.
Stage 2 — Diagnose. Inventory the current state with concrete evidence: metrics, quotes, screenshots, configs, tickets. Separate facts from interpretations. Identify the two or three root causes that explain most of the gap, not the long tail of symptoms.
Stage 3 — Design. Generate at least two viable options. For each option, capture: what changes, who owns it, what it costs, what it unblocks, what it risks, and how it could fail. Recommend one with a written rationale.
Stage 4 — Execute. Convert the chosen option into a sequenced plan: milestones, owners, dependencies, gating checks, communication cadence, and rollback triggers. Anything that cannot be assigned an owner and a date is not yet a plan.
Stage 5 — Validate. Define how success will be measured, when the measurement happens, and what action follows each possible result. Schedule the retrospective before the work starts, not after.
Depending on the request, the skill returns one or more of:
Every artifact uses clear headings, short paragraphs, and tables where comparison helps. No filler. No restating the prompt. No hedging language when a recommendation is warranted.
The skill applies the following heuristics when choices are not obvious:
| Anti-pattern | Why it fails | What the skill does instead |
|---|---|---|
| Generic best-practice list with no context | Reader cannot act on it | Tailors recommendations to the stated constraints |
| Recommendation without trade-offs | Hides the cost of being wrong | Names the price paid for the recommendation |
| Plan with no owners or dates | Cannot be executed or tracked | Assigns a named owner and a date to every action |
| Metrics theatre | Measures activity, not outcome | Ties every metric back to the user or business outcome |
| Boil-the-ocean scope | Nothing ships | Cuts scope to the smallest valuable slice |
| Buried recommendation | Reader misses the point | Leads with the recommendation in the first paragraph |
The skill self-checks each output against these gates before returning it:
If any gate fails, the skill rewrites the section before returning it.
Context: Define a meaningful test coverage strategy beyond line counts. Outputs coverage goals by risk tier, measurement approach, gap analysis, and improvement roadmap.
Frame: the team needs a defensible recommendation within five working days; the audience is a cross-functional steering group; the cost of delay is higher than the cost of being slightly wrong.
Diagnose: the dominant constraint is decision latency, not analytical depth. Existing data is sufficient for a directional call.
Design: two viable options surfaced. Option A optimises for speed and reversibility. Option B optimises for completeness but slips the deadline by two weeks.
Execute: Option A recommended. Plan sequenced into a two-week sprint with named owners, a mid-point checkpoint, and a clear rollback trigger.
Validate: success measured against a single leading indicator at day 30 and a single lagging indicator at day 90. Retrospective scheduled for day 35.
A one-shot artifact rarely changes outcomes. The skill recommends a lightweight cadence to keep the work alive: