simplicity-hunter-ts

Audit TypeScript code for structural complexity and recommend minimal implementations.

5|Updated Jan 14, 2026

Search Tags:#typescript #refactoring #complexity #deduplication #code-review #guard-clauses

Ready to run

npx skills add https://github.com/skyosev/agent-skills --skill simplicity-hunter-ts

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: simplicity-hunter-ts
Source: https://github.com/skyosev/agent-skills/tree/main/hunter-party-ts/simplicity-hunter-ts
Command: npx skills add https://github.com/skyosev/agent-skills --skill simplicity-hunter-ts

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Audit TypeScript code for structural complexity, including duplication, unnecessary abstractions, dead logic paths, flag-heavy APIs, deep nesting, and mixed concerns. Recommends the simplest shape that preserves intended behavior.

Core Features & Use Cases

Deduplicate logic across modules and tests to reduce surface area.
Inline trivial abstractions and guard against deep nesting with early returns.
Detect unintended mixed concerns and over-parameterized APIs to simplify interfaces.
Identify dead code paths and non-contributing branches during refactors.
Promote a single canonical path and focused helpers to improve maintainability.

Quick Start

Run a guided audit to surface structural complexity in your TypeScript codebase and generate a prioritised simplification plan.

Frequently Asked Questions about simplicity-hunter-ts

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

FAQPage Schema

How do I reduce structural complexity in TypeScript code during a refactor?▼

Reduce TypeScript structural complexity by auditing modules and tests to detect duplication, unnecessary abstractions, and deep nesting, then applying minimal canonical implementations to enforce simplicity.

What is the best way to deduplicate logic and simplify TypeScript APIs?▼

Deduplicate TypeScript logic by identifying repeated patterns across modules, inlining trivial wrappers, and simplifying over-parameterized APIs to promote a single canonical path and focused helpers.

How do I detect dead code paths and mixed concerns in a TypeScript codebase?▼

Detect dead code paths and mixed concerns in TypeScript by running a structural audit that flags non-contributing branches and over-parameterized APIs, recommending the simplest shape that preserves behavior.

Can I use guard clauses to fix deep nesting in TypeScript code reviews?▼

Yes, you can fix deep nesting in TypeScript code reviews by applying guard clauses with early returns to flatten control flow and remove unnecessary wrappers.

When should I audit TypeScript code for unnecessary abstractions and flag-heavy APIs?▼

Audit TypeScript code for unnecessary abstractions and flag-heavy APIs during new code reviews, refactoring efforts, and pre-merge audits to surface duplicated logic and mixed concerns before they reduce maintainability.