architecture-design

Design system architecture and document structural decisions for software projects.

39|2|Updated Jan 31, 2026
One-click install
npx skills add https://github.com/hffmnnj/opencode-goopspec --skill architecture-design-hffmnnj
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-design
Source: https://github.com/hffmnnj/opencode-goopspec/tree/main/skills/architecture-design
Command: npx skills add https://github.com/hffmnnj/opencode-goopspec --skill architecture-design-hffmnnj

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing robust software systems across teams can be ambiguous without a shared blueprint. This Skill provides a principled framework to conceive, document, and compare architectural options before coding.

Core Features & Use Cases

  • Principled design: Applies essential architectural principles (Separation of Concerns, Dependency Inversion, Interface Segregation, Open/Closed, Single Source of Truth) to guide decisions.
  • Pattern guidance: Recommends Layered, Clean Architecture, and Hexagonal patterns with concrete benefits and tradeoffs.
  • Use Case: When starting a new system, use this Skill to draft a scalable architecture plan, select appropriate patterns, and prepare a decision log for stakeholders.

Quick Start

Draft a scalable architecture for a new feature, selecting a pattern (Layered, Clean, or Hexagonal) and outlining key components in a few bullet points.

Frequently Asked Questions about architecture-design

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

FAQPage Schema
How do I design a scalable software architecture for a new system?

Design scalable architecture by applying core principles—Separation of Concerns, Dependency Inversion, Interface Segregation, Open/Closed, and Single Source of Truth—then select a pattern (Layered, Clean, or Hexagonal) based on your system's requirements. Document decisions and tradeoffs for stakeholder review.

What are the main architecture patterns and when should I use each one?

Layered, Clean, and Hexagonal patterns each offer distinct tradeoffs. Layered suits traditional multi-tier systems; Clean Architecture enforces strict dependency rules for testability; Hexagonal isolates business logic from external dependencies. Choose based on team experience, project complexity, and scalability needs.

How do I document architectural decisions for my team?

Create a decision log capturing each architectural choice, its rationale, and tradeoffs. This structured documentation clarifies reasoning for stakeholders, enables code reviews aligned with principles, and helps teams maintain consistency across components.

What principles should guide my system architecture decisions?

Five core principles guide robust architecture: Separation of Concerns (distinct responsibilities per component), Dependency Inversion (depend on abstractions), Interface Segregation (focused, minimal interfaces), Open/Closed (extensible without modification), and Single Source of Truth (no duplicated state across systems).

Can I use architecture patterns across different team sizes and project scopes?

Yes. Layered, Clean, and Hexagonal patterns scale across contexts—from small feature teams to large distributed systems. Select the pattern that balances your team's expertise, project complexity, and long-term maintainability requirements.

What should I do before selecting an architecture pattern?

Understand your system's requirements, team constraints, and scalability goals. Apply core architectural principles to evaluate fit. Compare pattern tradeoffs—complexity, testability, flexibility—against your project's priorities before committing to a design.