review-tests

Audit test suites against acceptance criteria and propose mutation checks.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/CasaPerks/casaflow --skill review-tests-casaperks
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-tests
Source: https://github.com/CasaPerks/casaflow/tree/main/team/skills/review-tests
Command: npx skills add https://github.com/CasaPerks/casaflow --skill review-tests-casaperks

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents teams from being misled by test suites that “always pass” by verifying that tests fail when the underlying production behavior is intentionally broken.

Core Features & Use Cases

  • Coverage audit against specs: Compares test coverage to each acceptance criterion, marking happy paths and failure paths as strong, missing, or weak.
  • False-positive detection via mutation checks: Proposes targeted break-the-code mutations so developers can confirm whether tests genuinely detect regressions.
  • Test quality rubric scoring: Evaluates isolation, specificity, realistic inputs, edge-case coverage, and behavior-over-implementation, then summarizes findings with prioritized action items.
  • Real-world use case: After shipping a feature described by a Jira spec, use this skill to identify gaps where important error handling or permission logic is not actually exercised by tests.

Quick Start

Run /casaflow:review-tests with the relevant feature context so the skill can audit coverage, propose break tests, and produce a grade with actionable fixes.

Frequently Asked Questions about review-tests

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I verify my test suite catches real bugs instead of passing on false positives?

To verify your test suite catches real bugs, run a mutation testing audit that intentionally breaks production code to confirm tests fail. This skill generates targeted break mutations for developer-run verification against acceptance criteria.

What is mutation testing and when do I need it for acceptance criteria?

Mutation testing is an auditing technique that introduces targeted code breaks to check if tests detect regressions. You need it after shipping a feature to validate that acceptance criteria for auth, data writes, and error handling paths are genuinely exercised.

How do I audit test coverage against feature acceptance criteria?

You audit test coverage against acceptance criteria by generating a coverage table that marks happy paths and failure paths as strong, missing, or weak. This skill compares your tests directly to each specified criterion to identify gaps.

Can I use this test audit skill to evaluate test isolation and edge-case coverage?

Yes, you can evaluate test isolation, specificity, realistic inputs, and edge-case coverage using a test quality rubric. The skill scores these dimensions, then returns a letter-grade summary with prioritized action items for fixes.

What's the best way to check if error handling and permission logic are actually tested?

The best way to check if error handling and permission logic are tested is to propose specific break-the-code mutations for those paths. Developers run these mutations to confirm whether tests genuinely detect regressions in auth and data write logic.

Why does my test suite always pass even when the feature has untested error paths?

Your test suite always passes because tests may not assert the correct behavior, leading to false positives. A test audit with mutation checks intentionally breaks error handling code to expose whether your tests genuinely fail when regressions occur.