software-architecture--design-patterns

Identify and apply GoF patterns and refactoring to improve software architecture.

4|2|Updated Jan 11, 2026
One-click install
npx skills add https://github.com/nick-orton/vybz --skill software-architecture-design-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-architecture--design-patterns
Source: https://github.com/nick-orton/vybz/tree/main/src/vybz/library/skills/software-architecture--design-patterns
Command: npx skills add https://github.com/nick-orton/vybz --skill software-architecture-design-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provide clear guidance on applying proven design patterns, refactoring strategies, and clean-code principles to improve the structure, maintainability, and scalability of software systems.

Core Features & Use Cases

  • Understand and apply the Gang of Four patterns (Creational, Structural, Behavioral) to real-world code.
  • Learn refactoring approaches (e.g., Extract Method, Replace Conditional with Polymorphism) to evolve architectures without changing behavior.
  • Use this knowledge to critique architectures and propose maintainable, SOLID-compliant solutions in teams.

Quick Start

Demonstrate applying a specific pattern (e.g., Strategy) to simplify a conditional-based class and improve runtime behavior.

Frequently Asked Questions about software-architecture--design-patterns

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

FAQPage Schema
When do I need to apply Gang of Four design patterns in my codebase?

Apply Gang of Four design patterns when you need to improve software architecture for maintainability and scalability. They provide proven solutions for recurring problems, guiding you on when to use Creational, Structural, or Behavioral patterns effectively.

How do I refactor conditional logic using the Strategy pattern?

Refactor conditional logic using the Strategy pattern by replacing conditional-based classes with polymorphic behaviors. Extract specific algorithms into separate strategy classes, simplifying the main class and improving runtime behavior without altering external functionality.

What is the best way to ensure SOLID compliance during code refactoring?

Ensure SOLID compliance during refactoring by applying clean-code principles alongside structural improvements. Use techniques like Extract Method or Replace Conditional with Polymorphism to evolve architectures while maintaining dependency inversion and single responsibility.

How do I balance complexity trade-offs when implementing structural design patterns?

Balance complexity trade-offs in structural design patterns by evaluating the maintainability improvements against added architectural overhead. Validate the implementation by checking if the pattern genuinely simplifies dependencies and improves readability metrics across your real-world codebase.

Can I use design pattern mapping to critique and improve existing software architecture?

Yes, you can use design pattern mapping to critique existing software architecture. By identifying missing or misapplied patterns, you can propose SOLID-compliant refactoring strategies that improve code quality and maintainability for your team.