Skip to content
Skills Library
Programming · Building & coding

php-patterns

/php-patterns

Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.

Licence
MIT
Last repository change
14.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.

Original author description

Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.

How it works

  1. Before writing code
  2. Creational Patterns
  3. Structural Patterns
  4. Behavioral Patterns
  5. Architectural Patterns
  6. Anti-Patterns to Avoid
  7. Best Practices
Original SKILL.md headings · 114 lines, 650 words
SKILL.md preview
---
name: php-patterns
description: Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.
allowed-tools: Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch
---

# PHP Design Patterns

## Before writing code

**Fetch live docs**: Web-search `php design patterns examples` for current community patterns and best practices. For Magento-specific patterns, web-search `site:developer.adobe.com commerce php development components`.

## Creational Patterns

### Factory

Creates objects without exposing instantiation logic. In Magento, auto-generated Factory classes (`SomeModelFactory`) create non-injectable objects via `$factory->create()`.

**When to use**: When you need new instances (entities, models) rather than shared singletons. When the caller shouldn't know the concrete class.

### Builder

Constructs complex objects step by step. Magento's `SearchCriteriaBuilder`, `FilterBuilder`, `SortOrderBuilder` follow this pattern.

**When to use**: When object construction requires many optional parameters or multi-step assembly.

### Singleton (Shared Instance)

Single instance shared across the application. Magento's Object Manager shares instances by default. Explicit singleton is generally an anti-pattern — prefer DI container sharing.

**When to use**: Rarely — let the DI container manage instance sharing.

## Structural Patterns

### Proxy

Delays instantiation of resource-intensive dependencies. Magento auto-generates Proxy classes (`SomeClass\Proxy`) that create the real object only when a method is called.

**When to use**: When a class injects a heavy dependency it doesn't always use.

### Decorator

Wraps an object to add behavior without modifying the original. Used in Magento composite components and cache decorators.

**When to use**: When you need to add behavior to an object dynamically without subclassing.

### Composite

Treats individual objects and compositions uniformly. Magento's UI component tree and layout container system follow this pattern.

**When to use**: When you have tree-structured data or components.

## Behavioral Patterns

### Strategy

Defines a family of algorithms, encapsulates each one, makes them interchangeable. Magento shipping carriers and payment methods are strategy implementations.

**When to use**: When you have multiple algorithms for the same task and want runtime selection.

### Observer

Defines a one-to-many dependency. When one object changes state, all dependents are notified. Magento's event/observer system is a direct implementation.

**When to use**: When changes in one object should trigger actions in others without tight coupling.

### Repository

Mediates between domain and data mapping layers. Magento's repository interfaces (`ProductRepositoryInterface`) centralize all data access through a clean API.

**When to use**: Always — for any data access beyond simple reads. It's the standard Magento pattern.

### Command

Encapsulates a request as an object. Magento's Payment Gateway Command pattern uses this — authorize, capture, refund are separate command objects.

**When to use**: When you need to parameterize, queue, or log requests.

## Architectural Patterns

### Dependency Injection

Objects receive their dependencies through constructors rather than creating them. Magento's DI container (Object Manager + di.xml) is the foundation of the entire framework.

**When to use**: Always — it's the core pattern. Inject interfaces, not concrete classes.

### Service Layer

Defines an application's boundary with a layer of services that encapsulates business logic. Magento's Service Contracts (interfaces in `Api/`) form this layer.

**When to use**: Always — expose module functionality through service interfaces.

### Data Transfer Object (DTO)

Simple objects that carry data between processes. Magento's Data Interfaces (`Api/Data/`) are DTOs — they have getters/setters but no business logic.

**When to use**: When passing data across architectural boundaries (API, service layer).

## Anti-Patterns to Avoid

- **God Object** — classes that do too much (split into focused services)
- **Service Locator** — calling Object Manager directly (use constructor injection)
- **Anemic Domain Model** — models with only getters/setters (add behavior where appropriate)
- **Tight Coupling** — depending on concrete classes (depend on interfaces)
- **Hard-coded Dependencies** — instantiating with `new` (use factories or DI)

## Best Practices

- Program to interfaces, not implementations
- Favor composition over inheritance
- Keep classes focused (Single Responsibility)
- Use DI container for dependency management
- Use factories for creating non-shared instances
- Use proxies for lazy-loading expensive dependencies
- Use the strategy pattern for swappable algorithms
- Document which pattern a class implements

Fetch current framework documentation for exact interface signatures and implementation patterns before applying.

Versions

RepositoryScoreLicence
This page · OrcaQubits/agentic-commerce-skills-plugins100MIT
OrcaQubits/agentic-commerce-skills-plugins100MIT

Database snapshot: 13.11.2026 · package version 7b1e46603356 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100design-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.
  • 90design-patterns
    Select a design pattern from a symptom — strategy, observer, factory, adapter, decorator. Use when a structure resists change, or choosing between Gang-of-Four patterns.
  • 95design-patterns
    Common design patterns with Java examples (Factory, Builder, Strategy, Observer, Decorator, etc.). Use when user asks "implement pattern", "use factory", "strategy pattern", or when designing extensible components.
  • 100design-patterns
    Use this skill whenever the user wants to identify, apply, or refactor toward design patterns in their codebase. Triggers include: "apply design patterns", "identify patterns", "what patterns should I use", "refactor to strategy pattern", "apply factory method", "use observer…
  • 100design-patterns
    Identifies, implements, and refactors code using standard Design Patterns (GoF + Modern). Use when: design pattern, refactor pattern, strategy pattern, observer pattern, factory pattern, singleton.
  • 100design-patterns-ruby
    Comprehensive Ruby implementations of Gang of Four (GoF) design patterns. Use when implementing object-oriented design solutions, refactoring to reduce coupling, solving architecture problems, or when user mentions specific patterns (Factory, Singleton, Observer, Strategy, etc.) in Ruby context.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.