architecture-patterns

Guides macOS app architecture using SOLID principles, design patterns, and modular Swift code organization.

Updated May 11, 2026
One-click install
npx skills add https://github.com/cloudofgeorge/AI-hands-Engineer --skill architecture-patterns-cloudofgeorge
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/cloudofgeorge/AI-hands-Engineer/tree/main/skills/engineering/domains/macos/macos-development/architecture-patterns
Command: npx skills add https://github.com/cloudofgeorge/AI-hands-Engineer --skill architecture-patterns-cloudofgeorge

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Designing maintainable macOS application architecture is difficult without clear guidance on SOLID principles, design patterns, and modular code organization, often leading to tightly coupled and hard-to-refactor Swift codebases. ## Core Features & Use Cases - SOLID Principles in Swift: Provides real-world Swift examples for each SOLID principle along with refactoring patterns. - Design Pattern Reference: Covers MVVM, Repository, Factory, Observer (Combine), and Coordinator patterns with Swift implementations. - Modular Code Organization: Explains Swift Package Manager organization, feature modules, and DRY implementation. - Use Case: When refactoring a growing macOS app, consult this Skill to restructure view logic into MVVM, extract shared code into Swift packages, and apply SOLID principles to reduce coupling. ## Quick Start Ask the agent to review your macOS app's architecture and recommend SOLID principles, design patterns, and modular organization improvements.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I apply SOLID principles in Swift macOS apps?▼

Apply SOLID principles in Swift by following the detailed real-world examples and refactoring patterns in the solid-detailed reference. Each principle is illustrated with practical Swift code showing how to restructure tightly coupled classes into maintainable designs.

What design patterns should I use for macOS development?▼

Common macOS design patterns include MVVM for view logic separation, Repository for data access, Factory for object creation, Observer via Combine for reactive updates, and Coordinator for navigation flow. Each pattern includes Swift implementation examples.

How do I organize a macOS app into Swift packages?▼

Organize macOS apps using Swift Package Manager by splitting code into feature modules with clear boundaries. The modular design guidance covers package structure, feature module separation, and DRY implementation across modules.

When should I use MVVM versus Coordinator pattern?▼

Use MVVM to separate view logic from UI in individual screens, and Coordinator to manage navigation flow between screens. They work together: MVVM handles presentation state while Coordinator owns routing decisions.

Can this skill modify my Swift code directly?▼

No, this skill is restricted to read-only tools (Read, Glob, Grep). It analyzes and advises on architecture decisions but does not write or modify code files directly.