lightweight-design-analysis_skill

Overview

This skill analyzes code for design quality improvements across eight rigorous dimensions: Naming, Object Calisthenics, Coupling & Cohesion, Immutability, Domain Integrity, Type System, Simplicity, and Performance. It enforces an evidence-based protocol that first understands code flow, then evaluates each dimension with concrete file:line findings and actionable recommendations. Output is focused, reproducible, and includes code snippets and severity levels.

How this skill works

The skill auto-invokes an implementation-analysis protocol to build a precise model of code flow, responsibilities, and relationships with file:line references. It then inspects the code systematically across the eight dimensions, detecting concrete violations (e.g., generic names, nested indentation, feature envy, mutable state, anemic domain logic, poor types, duplication, or algorithmic inefficiency). For every finding it emits severity (🔴/🟡), exact locations, code examples, and suggested before/after fixes.

When to use it

• Requesting a design-level code review of a class or small module
• Looking for refactoring opportunities focused on maintainability
• Validating domain model integrity and invariants
• Assessing coupling, cohesion, and type-safety before release
• Investigating suspected performance hotspots with evidence

Best practices

• Always run the implementation-analysis step first to gather file:line flow before asserting issues
• Report every finding with explicit file:line and a code snippet demonstrating the problem
• Prioritize fixes with clear impact: protect invariants, reduce coupling, prefer immutability
• Aim for single-responsibility units and extract methods when indentation or complexity rises
• Prefer explicit domain types and readonly state to make illegal states unrepresentable
• Only flag performance issues when there is clear evidence and a meaningful payoff

Example use cases

• Analyze a UserService or Order module for feature envy and misplaced business logic
• Identify naming and primitive-obession issues in utility-heavy modules
• Detect mutable state and array mutations in a Cart/Checkout implementation
• Find nested logic violating Object Calisthenics and propose extraction points
• Locate O(n²) patterns (find/filter inside loops) and suggest Map-based refactors