test-hunter-ts

Audit TypeScript test suites for coverage gaps and brittle mocks.

5|Updated Jan 14, 2026
One-click install
npx skills add https://github.com/skyosev/agent-skills --skill test-hunter-ts
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: test-hunter-ts
Source: https://github.com/skyosev/agent-skills/tree/main/hunter-party-ts/test-hunter-ts
Command: npx skills add https://github.com/skyosev/agent-skills --skill test-hunter-ts

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Audit TypeScript test code for quality gaps — ensuring tests cover behavior rather than implementation details, and identifying brittle, over-mocked, or assertion-free tests. Use when you want to reduce test debt, improve reliability, and catch critical paths that lack coverage.

Core Features & Use Cases

  • Audit quality gaps in TS tests, focusing on coverage of critical business logic, error handling, and edge cases.
  • Identify brittle tests that couple to implementation details and duplicated setup.
  • Provide actionable guidance for rewriting tests to assert observable behavior and reduce unnecessary mocks.
  • Use Case: For a TS project with flaky tests, run the audit to surface where tests fail after refactors and prioritize improvements.

Quick Start

Review an existing TS test suite to identify coverage gaps and refactor brittle mocks.

Frequently Asked Questions about test-hunter-ts

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

FAQPage Schema
How do I audit TypeScript tests for brittle assertions and over-mocking?

Auditing TypeScript tests involves evaluating coverage on critical paths to reveal brittle assertions, over-mocking, and missing edge cases in production behavior. This process identifies tests coupled to implementation details and guides rewriting them to assert observable behavior instead.

What causes TypeScript tests to fail after refactoring production code?

TypeScript tests fail after refactors due to brittle tests that over-mock dependencies and couple to implementation details rather than observable behavior. Auditing the test suite surfaces these quality gaps and provides actionable guidance to reduce unnecessary mocks.

How do I find missing edge cases in my TypeScript test suite?

Finding missing edge cases requires auditing TypeScript test coverage to enforce evaluation of critical business logic and error handling paths. The audit highlights areas lacking meaningful assertions and guides test debt reduction for those production gaps.

Can I reduce test debt in a TypeScript project with flaky tests?

Reducing test debt in TypeScript projects with flaky tests requires auditing the suite to identify quality gaps, duplicated setups, and assertion-free tests. The audit prioritizes improvements by focusing coverage on critical paths and meaningful assertions.

Does this test audit work with existing TypeScript test suites?

The audit works by reviewing an existing TypeScript test suite without requiring external dependencies. It evaluates current coverage and test quality directly against the production code to surface over-mocking and missing edge cases.

When should I audit my TypeScript tests for coverage gaps?

You should audit TypeScript tests when experiencing flaky tests or preparing for refactoring to catch critical paths lacking coverage. The audit identifies test debt and ensures meaningful assertions exist before structural changes introduce regressions.