architecture-patterns

Translate functionality requirements into architecture patterns with C4-inspired views.

161|25|Updated Oct 22, 2025
One-click install
npx skills add https://github.com/romiluz13/cc10x --skill architecture-patterns-romiluz13
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/romiluz13/cc10x/tree/main/plugins/cc10x/skills/architecture-patterns
Command: npx skills add https://github.com/romiluz13/cc10x --skill architecture-patterns-romiluz13

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill ensures that architecture designs are purpose-built to support specific functionality, rather than being generic or misaligned. It guides the user through understanding existing architecture, mapping functionality flows to components, and making informed architecture decisions with documented trade-offs, preventing costly reworks.

Core Features & Use Cases

  • Context-Aware Design: Mandates understanding existing architecture and functionality requirements before designing.
  • Functionality-to-Architecture Mapping: Translates user, admin, system, and integration flows into concrete system contexts, containers, and components.
  • Decision Framework with Trade-offs: Provides a structured approach for architecture decisions, including options, pros/cons, and consequences.
  • C4-inspired Views: Guides the creation of System Context, Container, and Component views to visualize the architecture.
  • Use Case: When planning a new feature like "File Upload to CRM," use this skill to design the system's architecture, including storage, API services, and data models, ensuring it meets performance and integration constraints.

Quick Start

Design the architecture for the new real-time chat feature, focusing on message delivery and user presence functionality.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I translate functionality requirements into architecture patterns?

Translate functionality requirements into architecture patterns by mapping user and admin flows to system contexts, containers, and components. Document inputs, outputs, dependencies, and error handling for each flow, then align architectural decisions with functional needs using a C4-inspired approach to prevent misaligned designs.

What's the best way to design system architecture for API and data modeling?

Design system architecture by first understanding existing architecture and functional requirements, then mapping flows to components and defining dependencies. Use System Context, Container, and Component views to visualize relationships, document trade-offs for each architectural decision, and ensure the design meets both performance and integration constraints.

How do I map user flows to architecture components?

Map user flows to architecture components by documenting user, admin, system, and integration flows end-to-end. For each flow, identify inputs, outputs, and dependencies, then assign them to specific containers and components. This ensures functionality is directly supported by your architectural design with clear visibility into error handling and integration points.

When should I use a C4 model for system design?

Use a C4 model when designing systems where understanding existing architecture and functionality requirements upfront prevents costly reworks. It's essential for complex systems with multiple integration points, APIs, or data models where System Context, Container, and Component views clarify how flows map to architecture across different stakeholder perspectives.

What's the difference between functionality-first architecture and generic design patterns?

Functionality-first architecture designs systems purpose-built to support specific user and admin flows rather than applying generic patterns. It prioritizes mapping actual requirements to components with documented trade-offs, ensuring architectural decisions directly serve the system's intended functionality and constraints.

How do I document architecture decisions with trade-offs?

Document architecture decisions by outlining available options, listing pros and cons for each, and capturing consequences of your choice. This structured approach ensures decisions connect explicitly to functional requirements and integration considerations, creating a record of why specific architecture patterns were selected over alternatives.