patterns-creational

Apply creational design patterns to manage object creation in software systems.

7|Updated Jan 26, 2026
One-click install
npx skills add https://github.com/bricerising/enterprise-software-playbook --skill patterns-creational
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: patterns-creational
Source: https://github.com/bricerising/enterprise-software-playbook/tree/main/skills/patterns-creational
Command: npx skills add https://github.com/bricerising/enterprise-software-playbook --skill patterns-creational

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Create objects and manage construction logic in software systems by applying creational design patterns to decouple creation from usage, enabling variation across environments and easier testing.

Core Features & Use Cases

  • Pattern catalog: Factory Method, Abstract Factory, Builder, Prototype, and Singleton with guidelines on when to use each.
  • Decision guidance: rules for selecting the smallest viable pattern based on complexity, variants, and lifecycle requirements.
  • Implementation checklists: practical steps, anti-patterns, and testing strategies to keep object creation clean and maintainable.

Quick Start

Implement a small composition-root example that demonstrates selecting a creational pattern (e.g., Factory Method or Builder) to create variant objects.

Frequently Asked Questions about patterns-creational

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What are creational design patterns and when should I use them in software engineering?

Creational design patterns manage object creation logic to decouple construction from usage. Use them when your enterprise software system requires variation across environments, needs composition-root wiring boundaries, or demands safe, testable object creation.

How do I choose between Factory Method, Abstract Factory, Builder, and Prototype?

Choosing a creational pattern relies on decision guidance rules that select the smallest viable pattern based on your system's complexity, required variants, and specific object lifecycle requirements. Evaluate whether your construction logic varies by environment or by variant to decide.

How do I implement a composition root using creational design patterns?

Implement a composition root by applying creational patterns like Factory Method or Builder to wire variant objects. This enforces a clear construction boundary, decouples creation from usage, supports testability through interfaces, and keeps object creation maintainable.

Does the Singleton pattern hurt testability in enterprise-scale projects?

The Singleton pattern can hinder testability if it hides dependencies. This skill provides implementation checklists, anti-patterns, and testing strategies to ensure safe object creation, helping you manage lifecycle requirements without compromising interface-based testing.

What's the best way to decouple object creation from usage across different environments?

The best way to decouple object creation from usage across environments is applying creational design patterns like Abstract Factory. This approach manages variant construction logic safely, enforcing a composition-root boundary while enabling easier testing and maintainable code.