design-patterns-implementation

Apply appropriate design patterns (Singleton, Factory, Observer, Strategy, etc.) to solve architectural problems. Use when refactoring code architecture, implementing extensible systems, or following SOLID principles.

Stars 151

Forks 20

Install this agent skill to your Project

npx add-skill https://github.com/aj-geddes/useful-ai-prompts/tree/main/skills/design-patterns-implementation

SKILL.md

Design Patterns Implementation

Overview
When to Use
Quick Start
Reference Guides
Best Practices

Overview

Apply proven design patterns to create maintainable, extensible, and testable code architectures.

When to Use

Solving common architectural problems
Making code more maintainable and testable
Implementing extensible plugin systems
Decoupling components
Following SOLID principles
Code reviews identifying architectural issues

Quick Start

Minimal working example:

typescript

class DatabaseConnection {
  private static instance: DatabaseConnection;
  private connection: any;

  private constructor() {
    this.connection = this.createConnection();
  }

  public static getInstance(): DatabaseConnection {
    if (!DatabaseConnection.instance) {
      DatabaseConnection.instance = new DatabaseConnection();
    }
    return DatabaseConnection.instance;
  }

  private createConnection() {
    return {
      /* connection logic */
    };
  }
}

// Usage
const db1 = DatabaseConnection.getInstance();
const db2 = DatabaseConnection.getInstance();
// ... (see reference guides for full implementation)

Reference Guides

Detailed implementations in the references/ directory:

Guide	Contents
Singleton Pattern	Singleton Pattern
Factory Pattern	Factory Pattern
Observer Pattern	Observer Pattern
Strategy Pattern	Strategy Pattern
Decorator Pattern	Decorator Pattern
Repository Pattern	Repository Pattern
Dependency Injection	Dependency Injection

Best Practices

✅ DO

Choose patterns that solve actual problems
Keep patterns simple and understandable
Document why patterns were chosen
Consider testability
Follow SOLID principles
Use dependency injection
Prefer composition over inheritance

❌ DON'T

Apply patterns without understanding them
Over-engineer simple solutions
Force patterns where they don't fit
Create unnecessary abstraction layers
Ignore team familiarity with patterns

Search AI Tools