Code Smell Detection

This skill provides a systematic approach to identifying code smells based on Martin Fowler's refactoring catalog.

Smell Categories

1. Bloaters

Code that has grown too large to handle effectively.

Long Method

Signs:

• Method longer than 20 lines
• Multiple levels of indentation
• Comments explaining what code does (not why)
• Difficulty naming the method

Detection Pattern:

- Count lines in method
- Count nesting depth
- Look for inline comments explaining code blocks

Refactoring: Extract Method

Large Class

Signs:

• Class with more than 200 lines
• More than 10 methods
• Multiple unrelated responsibilities
• "And" in class name (UserAndOrderManager)

Detection Pattern:

- Count methods and fields
- Identify cohesion (do fields relate to each other?)
- Check for multiple domains in one class

Refactoring: Extract Class, Extract Subclass

Long Parameter List

Signs:

• More than 3 parameters
• Boolean parameters
• Parameters that are always passed together

Detection Pattern:

- Count parameters
- Look for boolean flags
- Identify parameter groups

Refactoring: Introduce Parameter Object, Replace Parameter with Method Call

Data Clumps

Signs:

• Same group of variables passed together
• Similar fields in multiple classes
• Repeated parameter groups

Detection Pattern:

- Find repeated parameter combinations
- Look for similar field groups

Refactoring: Extract Class, Introduce Parameter Object

2. Object-Orientation Abusers

Incomplete or incorrect application of OO principles.

Switch Statements

Signs:

• Switch/case on type codes
• Repeated type checking
• instanceof chains
• Similar conditionals in multiple methods

Detection Pattern:

- Find switch statements
- Look for type checking patterns
- Identify polymorphism opportunities

Refactoring: Replace Conditional with Polymorphism, Replace Type Code with Subclasses

Parallel Inheritance Hierarchies

Signs:

• Creating subclass in one hierarchy requires subclass in another
• Prefixes match between hierarchies (DesktopController, DesktopView)

Detection Pattern:

- Compare class hierarchies
- Look for matching prefixes

Refactoring: Move Method, Move Field to consolidate hierarchies

Refused Bequest

Signs:

• Subclass only uses some inherited methods
• Overrides methods to do nothing
• Subclass throws NotImplementedException

Detection Pattern:

- Find empty method overrides
- Look for NotImplemented patterns
- Check inheritance usage

Refactoring: Replace Inheritance with Delegation

3. Change Preventers

Patterns that make code hard to modify.

Divergent Change

Signs:

• One class modified for multiple unrelated reasons
• Changes to one feature require changes to many methods
• Class is a "God class"

Detection Pattern:

- Analyze git history for change patterns
- Identify unrelated modifications
- Check commit messages for variety

Refactoring: Extract Class (one per change reason)

Shotgun Surgery

Signs:

• One change requires modifications in many classes
• Related code scattered across codebase
• Features spread thin

Detection Pattern:

- Trace feature implementation across files
- Count files touched per feature

Refactoring: Move Method, Move Field, Inline Class

4. Dispensables

Unnecessary code that can be removed.

Dead Code

Signs:

• Unreachable code after return/throw
• Unused variables, parameters, methods
• Commented-out code
• Feature flags that are always on/off

Detection Pattern:

- Static analysis for unused symbols
- Find unreachable code paths
- Detect TODO/FIXME/deprecated markers

Refactoring: Delete (safely, with tests)

Duplicate Code

Signs:

• Copy-pasted blocks
• Similar methods with minor variations
• Same algorithm implemented differently

Detection Pattern:

- Token-based similarity detection
- AST comparison
- Manual inspection of related code

Refactoring: Extract Method, Extract Class, Template Method

Speculative Generality

Signs:

• Abstract classes with single implementation
• Parameters never used
• Methods only called in tests
• "Future-proofing" comments

Detection Pattern:

- Find abstract types with one implementation
- Check parameter usage
- Analyze call sites

Refactoring: Collapse Hierarchy, Inline Class, Remove Parameter

5. Couplers

Excessive coupling between classes.

Feature Envy

Signs:

• Method uses more features from another class than its own
• Long chains of getters
• Data class with logic elsewhere

Detection Pattern:

- Count references to other classes vs own fields
- Identify data access patterns

Refactoring: Move Method, Extract Method then Move

Inappropriate Intimacy

Signs:

• Classes access each other's private parts
• Bidirectional dependencies
• Friend classes / package-private abuse

Detection Pattern:

- Analyze access patterns
- Check for circular dependencies

Refactoring: Move Method, Move Field, Hide Delegate

Message Chains

Signs:

• a.getB().getC().getD().doSomething()
• Law of Demeter violations
• Navigation through object graph

Detection Pattern:

- Find long method chains
- Count dots in expressions

Refactoring: Hide Delegate, Extract Method

Detection Checklist

When analyzing code, check for each smell category:

## Bloaters
- [ ] Long Method (>20 lines)
- [ ] Large Class (>200 lines, >10 methods)
- [ ] Long Parameter List (>3 params)
- [ ] Data Clumps

## OO Abusers
- [ ] Switch Statements on type
- [ ] Parallel Inheritance
- [ ] Refused Bequest

## Change Preventers
- [ ] Divergent Change
- [ ] Shotgun Surgery

## Dispensables
- [ ] Dead Code
- [ ] Duplicate Code
- [ ] Speculative Generality

## Couplers
- [ ] Feature Envy
- [ ] Inappropriate Intimacy
- [ ] Message Chains

Severity Levels

Classify each smell by impact:

Output Format

Report findings in this format:

# Smell Detection Report

## Summary
- Total smells found: N
- Critical: X
- High: Y
- Medium: Z
- Low: W

## Findings

### [CRITICAL] Long Method in UserService.processOrder
- **Location:** src/services/user_service.py:145-287
- **Lines:** 142
- **Issue:** Method handles order validation, payment, inventory, and notification
- **Recommendation:** Extract into separate methods per responsibility
- **Refactoring:** Extract Method (4-5 extractions needed)

### [HIGH] Feature Envy in OrderController.calculateTotal
- **Location:** src/controllers/order_controller.py:78
- **Issue:** Method accesses 8 fields from PricingService, only 1 from self
- **Recommendation:** Move method to PricingService
- **Refactoring:** Move Method