Skill Tree

Decouple object creation from usage. Add new types without modifying existing code.

Create consistent product families. Swap entire themes or variants in one place.

Build complex objects with readable fluent APIs. Avoid telescoping constructors.

Duplicate objects without knowing their concrete classes. Build prototype registries.

Control shared resource access. Ensure single-instance services like loggers and configs.

Integrate third-party libraries without modifying existing code. Bridge incompatible APIs.

Eliminate class explosion from multi-dimensional inheritance. Evolve dimensions independently.

Build recursive tree structures (menus, file systems, UI). Treat leaves and branches uniformly.

Stack behaviors dynamically at runtime. Combine features without subclass explosion.

Hide subsystem complexity behind a simple API. Reduce coupling between layers.

Optimize memory for millions of similar objects. Separate intrinsic from extrinsic state.

Add lazy loading, caching, access control, and logging without modifying the real object.

Build flexible middleware pipelines. Add/remove/reorder handlers without coupling.

Implement undo/redo, queuing, scheduling, and macro recording for any operation.

Traverse any data structure uniformly. Swap traversal algorithms without changing clients.

Decouple N components from each other. Centralize complex interaction logic.

Implement undo/redo and snapshots without breaking encapsulation.

Build event-driven systems. Decouple publishers from subscribers completely.

Eliminate state-based conditionals. Add new states without modifying existing ones.

Swap algorithms at runtime. Isolate and unit-test each algorithm independently.

Enforce algorithm structure while allowing step customization. Eliminate duplicated skeletons.

Add new operations to object hierarchies without modifying their classes.