code-smell-detector

Identify and quantify code smells and maintainability issues in JavaScript/TypeScript projects with severity scoring and file:line references.

Updated Apr 12, 2026
One-click install
npx skills add https://github.com/gil00pita/lanify --skill code-smell-detector-gil00pita
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-smell-detector
Source: https://github.com/gil00pita/lanify/tree/main/.agents/skills/code-smell-detector
Command: npx skills add https://github.com/gil00pita/lanify --skill code-smell-detector-gil00pita

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Detects and quantifies code smells, anti-patterns, and maintainability issues to guide targeted refactoring and improve code health.

Core Features & Use Cases

  • Quantified severity scoring with actionable evidence (file:line references)
  • Category-specific analysis (e.g., SOLID violations) across the repository
  • Practical remediation guidance and prioritization for technical debt reduction

Quick Start

Analyze a codebase to detect and score code smells with evidence and recommended refactor actions.

Frequently Asked Questions about code-smell-detector

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

FAQPage Schema
How do I detect code smells and quantify technical debt in a JavaScript codebase?

To detect code smells and quantify technical debt, you need static analysis that identifies anti-patterns and SOLID violations. This skill scans JavaScript and TypeScript projects, outputting prioritized findings with severity scores, file:line references, and remediation guidance.

What is the best way to find SOLID violations and maintainability issues across a repository?

Finding SOLID violations and maintainability issues requires repository-wide static analysis. This skill evaluates your codebase against SOLID principles, assigning quantified severity scores to each violation and providing actionable evidence with specific file and line references for targeted refactoring.

Can I use static analysis to prioritize refactoring tasks based on code quality metrics?

Yes, static analysis can prioritize refactoring by scoring code quality metrics. This skill calculates severity scores for detected code smells and anti-patterns, allowing you to prioritize technical debt reduction efforts based on quantified maintainability issues and practical remediation guidance.

Does code smell detection work with TypeScript projects and provide file line references?

Code smell detection works with both JavaScript and TypeScript projects. It provides actionable evidence for identified anti-patterns and maintainability issues by outputting exact file:line references, ensuring you can quickly locate and resolve SOLID violations across your repository.

What are common code smells and anti-patterns identified during static analysis?

Common code smells and anti-patterns identified during static analysis include SOLID violations and various maintainability issues. This skill detects these technical debt indicators across your repository, quantifying their severity and generating prioritized findings with actionable evidence to guide code improvements.

Why does maintainability degrade and how do I measure code health for refactoring?

Maintainability degrades due to accumulated code smells and anti-patterns. You measure code health by applying static analysis to quantify severity scores for technical debt, generating actionable evidence and prioritized findings that guide targeted refactoring to improve overall repository maintainability.