software-architecture

Diagnose design problems and route code to suitable design patterns.

6|1|Updated Dec 8, 2025
One-click install
npx skills add https://github.com/vladolaru/claude-code-plugins --skill software-architecture-vladolaru
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-architecture
Source: https://github.com/vladolaru/claude-code-plugins/tree/main/plugins/pirategoat-tools/skills/software-architecture
Command: npx skills add https://github.com/vladolaru/claude-code-plugins --skill software-architecture-vladolaru

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Diagnose design problems in code and guide the selection of the most appropriate design pattern to address coupling, rigidity, unclear responsibilities, and testability issues across GoF patterns, SOLID principles, hexagonal architecture, and composable designs.

Core Features & Use Cases

  • Identifies code smells and design pressures from the codebase.
  • Routes to the best-fit pattern reference (Strategy, Decorator, Hexagonal Architecture, Facade, etc.) and provides targeted guidance.
  • Provides a repeatable workflow to diagnose, route, recommend, and implement refactors with concrete before/after guidance.

Quick Start

Analyze a problem, pick a reference pattern, and outline a concrete refactor plan.

Frequently Asked Questions about software-architecture

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

FAQPage Schema
How do I diagnose code smells and choose the right design pattern for refactoring?

To diagnose code smells and choose a design pattern, analyze tight coupling, rigid architectures, and unclear responsibilities. Route these design problems to the best-fit GoF pattern, SOLID principle, or hexagonal architecture, and outline a concrete refactor plan with before and after guidance.

How do I fix hard-to-test code using hexagonal architecture and SOLID principles?

Fix hard-to-test code by applying hexagonal architecture and SOLID principles to separate core logic from external dependencies. Diagnose unclear responsibilities and tight coupling, then route them to a composable design pattern that isolates business rules for easier unit testing.

What is the best way to resolve tight coupling and rigid architectures in my codebase?

The best way to resolve tight coupling and rigid architectures is diagnosing the specific design pressures and routing them to suitable structural patterns. Apply targeted refactor steps using SOLID principles or composable designs to decouple modules and restore architectural flexibility.

When do I need a design pattern reference for software architecture decisions?

You need a design pattern reference when diagnosing design problems like coupling, rigidity, or testability issues. Use it to route the identified code smell to the most suitable GoF pattern, hexagonal architecture, or SOLID principle, and generate actionable before and after refactoring guidance.

How do I implement a Strategy or Decorator pattern refactor after identifying a code smell?

To implement a Strategy or Decorator pattern refactor, diagnose the design problem, route it to the chosen pattern reference, and follow the actionable implementation steps. Use the provided before and after guidance to replace rigid logic with composable, decoupled designs.