skills.rest
GrizzwaldHouse
GrizzwaldHouseCOMMUNITY
Explore all skills by this author →
GitHub

architecture-patterns

Provide architectural patterns and file organization conventions for software projects.

6|1|Updated Feb 10, 2026
Search Tags:#architecture#design patterns#software design#code organization#UI architecture#separation of concerns
One-click install
npx skills add https://github.com/GrizzwaldHouse/cowork-skills --skill architecture-patterns-grizzwaldhouse
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/GrizzwaldHouse/cowork-skills/tree/main/skills/architecture-patterns
Command: npx skills add https://github.com/GrizzwaldHouse/cowork-skills --skill architecture-patterns-grizzwaldhouse

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a comprehensive playbook for structuring software projects, ensuring maintainability, scalability, and clear organization across different languages and frameworks.

Core Features & Use Cases

  • Architectural Patterns: Implements core design patterns like Observer, Composition, Interface-Driven Design, Data-Driven Design, Repository Pattern, and Separation of Concerns.
  • UI Architecture: Defines clear rules for separating state management from rendering and event handling.
  • File Organization: Offers conventions for organizing code by feature/domain rather than file type.
  • Naming Conventions: Provides language-specific naming guidelines.
  • Use Case: When starting a new web application, use this Skill to guide the file structure, define how components communicate using the Observer pattern, and establish clear interfaces for data access via the Repository pattern.

Quick Start

Apply Marcus's architecture patterns to design the architecture for a new user authentication feature in a React application.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I structure a software project for maintainability and scalability?▼

Software project structure is established by organizing code by feature or domain rather than file type. This approach ensures maintainability, clear separation of concerns, and provides language-specific naming conventions to support scalability.

What is the best way to separate state management from UI rendering?▼

State management separation is achieved through defined UI architecture standards that isolate rendering from event handling. Applying these architectural rules ensures clear boundaries between state logic and user interface components.

How do I implement the Repository pattern for data access in my application?▼

The Repository pattern is implemented using interface-driven design to establish clear data access boundaries. This architectural pattern abstracts data operations, ensuring separation of concerns between data sources and application logic.

When should I use the Observer pattern for component communication in web applications?▼

The Observer pattern should be used when components require a decoupled communication mechanism for state updates. This architectural pattern allows components to subscribe to changes, preventing direct dependencies and maintaining code organization.

Does this architecture guidance support language-specific file organization conventions?▼

Yes, the architecture guidance supports language-specific file organization conventions. It provides tailored naming guidelines and structural rules for organizing code by project type across different programming languages and frameworks.

What is the difference between composition and interface-driven design for software architecture?▼

Composition combines smaller functional units into complex structures, while interface-driven design establishes explicit contracts for data access like the Repository pattern. Both architectural patterns enforce separation of concerns but address different structural layers.

Related Skills

Explore More Software Engineering Skills→
KaakatiKaakati
10

Codebase Inspection Protocol

Inspect Rails project structure, patterns, dependencies, and naming conventions.

Community
Intermediate
markeriksonmarkerikson
41

code-style-review

Document coding conventions from configuration files and source code examples.

Community
Intermediate
MatthieuszMatthieusz

coding-standards

Validate TypeScript code against predefined coding standards using static analysis tools.

Community
Advanced
VMRam95VMRam95

stick-crisis-check-arch

Validate Unity C# class placement against DDD and Hexagonal architecture constraints.

Community
Basic