solid-hunter-ts

Audit TypeScript code for SOLID principle violations at class and interface levels.

5|Updated Jan 14, 2026

Search Tags:#typescript #refactoring #design-principles #solid #class-design #code-audit

Ready to run

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

💬 Prompt for ChatGPT / Claude Chat▼

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Audit SOLID design violations in TypeScript code, helping teams improve maintainability, testability, and long-term extensibility by clarifying responsibilities.

Core Features & Use Cases

Detect god classes that violate SRP by aggregating responsibilities across multiple concerns.
Identify rigid extension points and dependency inversion pitfalls to enable safer extension and substitution.
Provide actionable guidance for refining interfaces, abstractions, and class responsibilities.
Use Case: During major refactors or when planning new variants, to ensure changes stay isolated and testable.

Quick Start

Run a SOLID audit on your TypeScript codebase to identify class- and interface-level violations.

Frequently Asked Questions about solid-hunter-ts

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

FAQPage Schema

How do I audit TypeScript code for SOLID principle violations?▼

To audit TypeScript code for SOLID violations, apply automated checks to your class and interface hierarchies to detect SRP, OCP, LSP, ISP, and DIP flaws, citing exact file paths for evidence and remediation guidance.

What is a god class in TypeScript and how do I identify it?▼

A god class in TypeScript violates SRP by aggregating responsibilities across multiple concerns. You identify it by auditing class structures to detect classes that handle multiple distinct tasks, reducing maintainability and testability.

Can I check for dependency inversion issues during a TypeScript refactor?▼

Yes, you can check for dependency inversion pitfalls during a TypeScript refactor by auditing rigid extension points and interface abstractions, ensuring safer extension and substitution while improving long-term extensibility.

Does this SOLID audit work for TypeScript codebases with complex hierarchies?▼

This SOLID audit works for TypeScript codebases with complex hierarchies, frequent refactors, or testability goals by explicitly evaluating class and interface designs to keep changes isolated and maintainable.

What's the best way to ensure testability when expanding TypeScript class variants?▼

The best way to ensure testability when expanding TypeScript class variants is to run a SOLID audit, clarifying class responsibilities and refining interfaces to keep changes isolated and testable during major refactors.

Why does my TypeScript interface design fail the Interface Segregation Principle?▼

TypeScript interface designs fail ISP when they force classes to implement methods they do not use. Auditing interface abstractions identifies these violations and provides actionable guidance for refining class responsibilities.