The Standard Architecture

Design Standard-compliant systems into brokers, services, and exposers.

18|6|Updated Mar 25, 2026
One-click install
npx skills add https://github.com/hassanhabib/the-standard-skills --skill the-standard-architecture-hassanhabib
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: The Standard Architecture
Source: https://github.com/hassanhabib/the-standard-skills/tree/main/.skills/the-standard-architecture
Command: npx skills add https://github.com/hassanhabib/the-standard-skills --skill the-standard-architecture-hassanhabib

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The Standard Architecture provides a proven blueprint for designing and organizing complex software systems into clear layers: Exposers, Services, and Brokers, following a strict flow of control and responsibility.

Core Features & Use Cases

  • Architecting systems with a tri-nature model (Brokers, Services, Exposers) to separate concerns and enforce boundaries.
  • Defining and validating dependencies, REST API conventions, and UI architecture using standardized rules.
  • Useful for architecture reviews, system refactors, and designing new components with consistent patterns.

Quick Start

Start by mapping a domain to Exposer → Service → Broker, then incrementally add Foundation, Processing, Orchestration, and Exposer layers following the architecture rules.

Frequently Asked Questions about The Standard Architecture

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

FAQPage Schema
How do I structure software into services, brokers, and exposers for clear separation of concerns?

Software architecture separation of concerns is achieved by mapping domains to a tri-nature model: Exposers handle entry points, Services manage logic, and Brokers interact with data. This enforces strict flow of control and boundaries across system components.

What is the Florance pattern for decomposing systems into services and brokers?

The Florance pattern is a system design blueprint that structures software into Foundation, Processing, Orchestration, and Exposer layers. It enforces 2-3 dependencies per component and clear mapping to separate control flow from data access.

How to design REST API conventions and validate dependencies during architecture reviews?

REST API conventions and dependency validation are governed by applying standardized architecture rules during system design. You map domains to Exposer, Service, and Broker layers, enforcing 2-3 dependencies and strict exception categorization.

When do I need to enforce UI architecture conventions and dependency limits during refactoring?

UI architecture conventions and dependency limits are needed during system refactors to maintain clear boundaries. Enforcing 2-3 dependencies and standardized UI rules prevents control flow leakage and ensures consistent component mapping.

Can I use this architecture pattern for designing new components with existing REST APIs?

Yes, designing new components with existing REST APIs fits this architecture by incrementally adding Foundation, Processing, Orchestration, and Exposer layers. This enforces standardized rules and clear mapping without disrupting current API contracts.

What is the best way to categorize exceptions and map dependencies in service-oriented architecture?

Categorizing exceptions and mapping dependencies in service-oriented architecture requires enforcing strict rules where Services depend on Brokers, and Exposers depend on Services. This limits dependencies to 2-3 per layer and ensures clear exception categorization.