Software Architecture

Codify Gosling2 architectural rules for four-layer stack import permissions.

Updated Dec 9, 2025
One-click install
npx skills add https://github.com/PROdotes/Gosling2 --skill software-architecture-prodotes
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Software Architecture
Source: https://github.com/PROdotes/Gosling2/tree/main/.agent/skills/software-architecture
Command: npx skills add https://github.com/PROdotes/Gosling2 --skill software-architecture-prodotes

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill codifies Gosling2's architectural rules to prevent architectural drift and enforce maintainable, modular design across the codebase.

Core Features & Use Cases

  • Layered Hierarchy enforcement: UI (src/presentation/), Business (src/business/), Data (src/data/), and Core (src/core/) with explicit import permissions to avoid cross-layer coupling.
  • Governance & modularization: God Object ban (no file > 600 lines) and splitting guidance to keep components focused and maintainable.
  • Service Bus discipline: Sibling widgets communicate via a central LibraryService or EventBus to decouple UI and business logic.
  • Resource discipline: Centralized constants, logging, utilities, and config practices with no inline UI logic in data layer.
  • Use Case: When adding a new feature, teams map code to the four layers and document dependencies to prevent leakage.

Quick Start

Review the existing architecture rules in rules/architecture.md and ensure new modules conform to the four-layer model, service-bus communication, and god-object guidelines; update governance documentation as needed.

Frequently Asked Questions about Software Architecture

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

FAQPage Schema
How do I enforce strict layered architecture and prevent forbidden imports?

Strict layered architecture is enforced by codifying explicit import permissions across Presentation, Business, Data, and Core layers, preventing cross-layer coupling and architectural drift in the codebase.

What is the best way to stop god objects and keep code modules maintainable?

Mitigating god objects requires banning any source file exceeding 600 lines and applying splitting guidance to keep components focused, modular, and maintainable during codebase growth.

How do I decouple UI widgets and business logic without direct coupling?

Decouple sibling UI widgets and business logic by routing communication through a central LibraryService or EventBus, enforcing strict separation between presentation and business layers.

Can I use this architectural governance for a four-layer stack project?

Yes, this architecture governance suits a four-layer stack by specifying concrete directory structures, dependency rules, and resource discipline practices tailored exactly to that model.

Why does inline UI logic in the data layer break modularization?

Inline UI logic in the data layer breaks modularization by violating resource discipline, which mandates centralized constants, logging, and config practices to isolate data processing from presentation concerns.

How do I map a new feature to architectural layers and prevent leakage?

Map new features to the four architectural layers and document their dependencies to verify service-bus usage and prevent forbidden imports or logic leakage across module boundaries.