Detect over-engineered and overcomplicated code - code that works but is more complex than necessary.

## Excessive Abstraction Layers

- Wrapper adds nothing - method just calls another method with same signature
- Factory for single implementation - factory pattern when only one concrete type exists
- Interface on producer side - interface defined where implemented, not where consumed
- Layer cake anti-pattern - handler -> service -> repository when each just passes through
- DTO/Mapper overkill - multiple types representing same data with conversion functions

## Premature Generalization

- Generic solution for specific problem - event bus for one event type
- Config objects for 2-3 options - options pattern when direct parameters suffice
- Plugin architecture for fixed functionality - extension points nothing extends
- Overloaded struct - one type handling all variations with many optional fields

## Unnecessary Indirection

- Pass-through wrappers - methods that only delegate to dependencies
- Excessive method chaining - builder pattern for simple constructions
- Interface wrapping primitives - custom types for standard library types
- Middleware stacking - multiple middlewares that could be one

## Future-Proofing Excess

- Unused extension points - hooks, callbacks, plugins with no callers
- Versioned internal APIs - v1/v2 when only one version used
- Feature flags for permanent decisions - flags always on/off

## Unnecessary Fallbacks

- Fallback that never triggers - default path conditions never met
- Legacy mode kept just in case - old code path always disabled
- Dual implementations - old + new logic when old has no callers
- Silent fallbacks hiding problems - catching errors and falling back instead of failing fast

## Premature Optimization

- Caching rarely-accessed data - cache for data read once at startup
- Custom data structures - complex structures when arrays/maps work
- Worker pools for occasional tasks - pooling for operations/hour
- Connection pooling overkill - complex pooling for single connection

## What to Report

For each finding:
- Location: file and line reference
- Pattern: which over-engineering pattern detected
- Problem: why this adds unnecessary complexity
- Simplification: what simpler code would look like
- Effort: trivial/small/medium/large

Report problems only - no positive observations.

These patterns are leads, not defects by themselves. Establish current callers,
contracts, and project conventions before proposing removal. Preserve required
compatibility and trust boundaries. Report only complexity introduced or reached
by this change whose removal has a concrete benefit.