Analyzing Patterns
You are an expert in recognizing software design patterns, architectural patterns, and code organization strategies. This skill provides systematic pattern analysis to identify recurring structures, conventions, and design decisions in codebases.
Your Capabilities
- Design Pattern Recognition: Identify Gang of Four and modern design patterns
- Architectural Pattern Analysis: Recognize system-level patterns and structures
- Code Pattern Detection: Find repeated code structures and conventions
- Convention Extraction: Document naming, organization, and style patterns
- Anti-Pattern Identification: Spot problematic patterns and suggest improvements
When to Use This Skill
Claude should automatically invoke this skill when:
- User asks "what patterns are used in this code?"
- Questions about "find repeated/duplicated code"
- Requests to "analyze the architecture"
- Asking about "design patterns in this codebase"
- Understanding code organization strategies
- Identifying naming conventions
- Recognizing structural similarities
- Refactoring opportunities
- Code review focusing on patterns
Pattern Analysis Methodology
Phase 1: Pattern Discovery
1. Scan for structural patterns
- File/directory organization
- Naming conventions
- Import/export patterns
2. Identify design patterns
- Creational (Factory, Singleton, Builder)
- Structural (Adapter, Decorator, Facade)
- Behavioral (Observer, Strategy, Command)
3. Recognize architectural patterns
- MVC, MVVM, MVP
- Layered architecture
- Microservices
- Event-driven
- Repository pattern
Phase 2: Pattern Analysis
1. Document each pattern
- Pattern name and type
- Where it's used (files, line numbers)
- Why it's used (intent)
- How it's implemented
2. Evaluate implementation
- Correctly implemented?
- Consistent usage?
- Appropriate for use case?
3. Note variations
- Different implementations
- Adaptations to context
- Deviations from standard
Phase 3: Synthesis & Reporting
1. Categorize findings
- Group by pattern type
- Organize by layer/component
- Prioritize by importance
2. Identify meta-patterns
- Overall architectural style
- Dominant paradigm (OOP, FP, etc.)
- Consistency level
3. Provide insights
- What patterns work well
- Where patterns are missing
- Refactoring opportunities
- Consistency improvements
Pattern Categories
Design Patterns (Gang of Four)
Creational Patterns
Factory Pattern
- Purpose: Object creation without specifying exact class
- Signs: factory(), create(), build() methods
- Files: factories/, creators/
Singleton Pattern
- Purpose: Single instance globally
- Signs: getInstance(), static instance, private constructor
- Files: config/, services/
Builder Pattern
- Purpose: Complex object construction step-by-step
- Signs: builder(), withX() chaining methods
- Files: builders/, constructors/
Prototype Pattern
- Purpose: Clone existing objects
- Signs: clone(), copy() methods
- Files: prototypes/, templates/
Abstract Factory Pattern
- Purpose: Families of related objects
- Signs: Multiple factory methods, product families
- Files: factories/abstract/
Structural Patterns
Adapter Pattern
- Purpose: Interface compatibility
- Signs: adapter classes, interface conversion
- Files: adapters/, wrappers/
Decorator Pattern
- Purpose: Add behavior without modifying
- Signs: Wrapper classes, enhanced functionality
- Files: decorators/, wrappers/
Facade Pattern
- Purpose: Simplified interface to complex system
- Signs: High-level API hiding complexity
- Files: facades/, api/
Proxy Pattern
- Purpose: Placeholder/surrogate for another object
- Signs: Proxy classes, lazy initialization
- Files: proxies/, surrogates/
Composite Pattern
- Purpose: Tree structures, part-whole hierarchies
- Signs: Recursive structures, children/parent relationships
- Files: composites/, tree/
Behavioral Patterns
Observer Pattern
- Purpose: Notify multiple objects of state changes
- Signs: subscribe(), notify(), event emitters
- Files: observers/, events/, pubsub/
Strategy Pattern
- Purpose: Interchangeable algorithms
- Signs: Strategy interfaces, algorithm selection
- Files: strategies/, algorithms/
Command Pattern
- Purpose: Encapsulate requests as objects
- Signs: Command classes, execute() methods, undo/redo
- Files: commands/, actions/
State Pattern
- Purpose: Behavior changes based on state
- Signs: State classes, transition methods
- Files: states/, state-machine/
Template Method Pattern
- Purpose: Algorithm skeleton with customizable steps
- Signs: Abstract base class with template method
- Files: templates/, base-classes/
Iterator Pattern
- Purpose: Sequential access to elements
- Signs: next(), hasNext(), iterators
- Files: iterators/, collections/
Chain of Responsibility
- Purpose: Pass request along chain of handlers
- Signs: Handler chains, next() delegation
- Files: handlers/, middleware/
Architectural Patterns
MVC (Model-View-Controller)
- Structure: models/, views/, controllers/
- Signs: Separation of data, UI, logic
MVVM (Model-View-ViewModel)
- Structure: models/, views/, viewmodels/
- Signs: Data binding, reactive updates
Repository Pattern
- Structure: repositories/, models/
- Signs: Data access abstraction
Service Layer Pattern
- Structure: services/, domain/
- Signs: Business logic encapsulation
Layered Architecture
- Structure: presentation/, business/, data/, infrastructure/
- Signs: Clear layer boundaries
Microservices Architecture
- Structure: Multiple services, each deployable
- Signs: Service boundaries, APIs, event buses
Event-Driven Architecture
- Structure: events/, handlers/, publishers/
- Signs: Publish/subscribe, event handlers
Hexagonal Architecture (Ports & Adapters)
- Structure: core/, ports/, adapters/
- Signs: Core domain isolated from external concerns
Code-Level Patterns
Naming Conventions
- camelCase, PascalCase, snake_case, kebab-case
- Prefixes: is/has/get/set/handle/on
- Suffixes: -er, -or, -able, -Service, -Controller
File Organization Patterns
- Feature-based (by domain)
- Layer-based (by type)
- Atomic design (atoms, molecules, organisms)
- Flat vs. nested structures
Module Patterns
- CommonJS: module.exports, require()
- ES Modules: export, import
- Barrel exports: index.js re-exports
- Namespace patterns
Error Handling Patterns
- Try-catch blocks
- Error boundaries (React)
- Result types (Ok/Err)
- Exception hierarchies
Async Patterns
- Callbacks
- Promises
- Async/await
- Observables/Streams
Analysis Strategies
Finding Design Patterns
# Factory Pattern
grep -r "factory\|create.*Function\|build.*Function" --include="*.ts"
# Singleton Pattern
grep -r "getInstance\|static.*instance" --include="*.js"
# Observer Pattern
grep -r "subscribe\|addEventListener\|on\(" --include="*.ts"
# Strategy Pattern
grep -r "interface.*Strategy\|class.*Strategy" --include="*.ts"
# Decorator Pattern
grep -r "@.*decorator\|class.*Decorator" --include="*.ts"
Finding Architectural Patterns
# MVC/MVVM structure
ls -la | grep -E "models|views|controllers|viewmodels"
# Repository pattern
grep -r "Repository" --include="*.ts"
find . -type d -name "*repository*"
# Service layer
find . -type d -name "*service*"
grep -r "class.*Service" --include="*.ts"
# Layered architecture
ls -la | grep -E "presentation|business|data|infrastructure"
Finding Code Patterns
# Naming patterns
grep -r "^export (function|class|const)" --include="*.ts" | head -50
# Import patterns
grep -r "^import" --include="*.ts" | sort | uniq -c | sort -rn
# Repeated code blocks
# (Manual analysis of similar structures)
Resources Available
Scripts
Located in {baseDir}/scripts/:
- pattern-detector.py: Automated pattern recognition in code
- duplicate-finder.sh: Find dupli