solid-principles_skill

Overview

This skill applies and validates SOLID principles in object-oriented code to identify design issues and suggest concrete improvements. It provides a compliance score, lists violations per principle, and can optionally show example fixes for detected problems. The skill is language-aware and configurable for strictness and focus areas.

How this skill works

The analyzer parses the provided code into an AST and inspects structural and behavioral indicators tied to each SOLID principle (SRP, OCP, LSP, ISP, DIP). It reports violations with locations, severity, and actionable suggestions, and computes a numeric compliance score along with per-principle metrics. Options let you focus on selected principles, adjust validation strictness, and include example refactorings.

When to use it

• Assess design quality during code reviews or refactoring planning
• Validate new implementations against SOLID before merging
• Identify responsibility or dependency problems in legacy or monolithic classes
• Measure progress after refactorings by tracking compliance score over time
• Enforce architectural guidance in CI pipelines or automated checks

Best practices

• Start with relaxed analysis to get broad insights, then increase strictness for targeted cleanup
• Run focused checks on one principle when addressing a specific smell (e.g., ISP for large interfaces)
• Use suggestions as a starting point; review proposed refactorings to fit domain constraints
• Split large files into modules before analyzing to avoid context overflow errors
• Combine automated results with manual review for behavioral issues not detectable statically

Example use cases

• Detect a god class violating SRP and get concrete extraction suggestions (services, repositories)
• Find switch/type checks that indicate OCP violations and propose strategy/template pattern opportunities
• Spot overridden methods that break LSP and highlight pre/postcondition mismatches
• Locate large interfaces or unused methods to guide ISP-driven interface segregation
• Reveal direct instantiation and missing abstractions to recommend dependency inversion via constructor injection