skills.rest
skyosev
skyosevCOMMUNITY
Explore all skills by this author →
GitHub

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
One-click install
npx skills add https://github.com/skyosev/agent-skills --skill simplicity-hunter-ts
Or copy as Structured Prompt for Agent▼
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.

Related Skills

Explore More Software Engineering Skills→
BerryKuipersBerryKuipers
7

record-quality-baseline

Record code quality metrics before refactoring into a timestamped JSON baseline.

Community
Intermediate
Tyler-R-KendrickTyler-R-Kendrick
1

ponytail-audit

Audit a codebase and rank simplification and code removal opportunities.

Community
Intermediate
ShaulLavoShaulLavo

never-nester

Enforce a maximum code nesting depth of 3 using extraction and inversion.

Community
Basic
CuriousLearnerCuriousLearner
27

complexity-analyzer

Measure code complexity metrics and identify high-complexity areas in software projects.

Community
Advanced