design

Select in-process code patterns for refactoring and extensibility needs.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pick the simplest design that fits, then map it to a code pattern only if it buys you clear leverage (change isolation, testability, reuse, or performance).

Core Features & Use Cases

  • Guided pattern selection: chooses among creational, structural, and behavioral families based on problem context.
  • Guardrails for safe refactors: minimizes coupling, preserves boundaries, and enhances testability.
  • Real-world workflows: provides a repeatable decision workflow that teams can adopt across modules.

Quick Start

Define the problem, review the pattern family, and select the recommended pattern with rationale.

Frequently Asked Questions about design

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

FAQPage Schema
How do I choose the right design pattern for a TypeScript refactoring task?

To choose a design pattern for TypeScript refactoring, define the problem context to select among creational, structural, or behavioral families. Apply a simple workflow with clear criteria to ensure the pattern provides clear leverage like change isolation and testability.

What is the simplest way to select in-process code patterns for module extensibility?

Selecting in-process code patterns involves picking the simplest design that fits your extensibility need, then mapping it to a pattern only if it buys clear leverage. This minimizes coupling and maximizes testability within a single module or small service.

When should I apply creational vs structural vs behavioral code patterns?

Apply creational, structural, or behavioral code patterns based on your specific problem context. Use guardrails to assess whether the pattern minimizes coupling, preserves boundaries, and enhances testability before implementing the refactoring.

What's the best way to reduce coupling when adding extensibility to a small service?

The best way to reduce coupling when extending a small service is using a guided pattern selection workflow. It applies guardrails to preserve boundaries and maximize testability, ensuring the chosen in-process design fits the architecture.

Does applying a design pattern always improve code architecture?

Applying a design pattern does not always improve architecture if it lacks clear leverage. You should map a problem to a code pattern only when it provides specific benefits like change isolation, testability, reuse, or performance.