system-architecture

Design system architectures with explicit boundaries and trade-offs.

Updated Apr 27, 2026
One-click install
npx skills add https://github.com/Tnemo65/template --skill system-architecture-tnemo65
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: system-architecture
Source: https://github.com/Tnemo65/template/tree/main/.cursor/skills/11-system-design/system-architecture
Command: npx skills add https://github.com/Tnemo65/template --skill system-architecture-tnemo65

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Design robust, maintainable architectures that match real requirements and avoid overengineering.

Core Features & Use Cases

  • Boundary delineation: Define clear module boundaries aligned to business capabilities.
  • Trade-off documentation: Explicitly capture performance, cost, and risk trade-offs.
  • Iterative design: Start simple and evolve as requirements evolve.

Quick Start

Provide your architecture requirements and constraints and the skill will propose a pragmatic, boundary-aware system design.

Frequently Asked Questions about system-architecture

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

FAQPage Schema
How do I design a scalable system architecture without overengineering?

System architecture design should match real requirements by starting simple and iterating. Capture performance, cost, and risk trade-offs explicitly to ensure robust, maintainable boundaries without unnecessary complexity.

What is the best way to define clear module boundaries for software projects?

Defining module boundaries requires aligning them to business capabilities. This ensures explicit dependency direction, controlled data flow, and structured failure handling across varying team sizes and project lifespans.

How do I document trade-offs when making system design decisions?

Trade-off documentation captures performance, cost, and risk factors explicitly during system design. This records architectural boundaries and dependency directions to guide iterative refinement as requirements evolve.

Can I apply iterative system design to small software projects?

Iterative system design scales across software projects of varying sizes. It starts with simple boundaries and evolves architecture as requirements change, preventing overengineering while maintaining robust failure handling.

Why does my system architecture fail to handle changing requirements?

System architecture fails when boundaries and trade-offs are implicit. Explicitly defining module boundaries, dependency direction, and failure handling allows iterative refinement to adapt to evolving requirements.

When do I need to explicitly define dependency direction in system architecture?

Dependency direction must be defined when establishing module boundaries in system architecture. It structures data flow and failure handling, ensuring the design remains maintainable and avoids overengineering.