architecture

Analyze software architecture decisions and document trade-off-driven recommendations.

2|Updated Apr 23, 2026
One-click install
npx skills add https://github.com/gajjalaashok75-UI/GakrCLI --skill architecture-gajjalaashok75-ui
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture
Source: https://github.com/gajjalaashok75-UI/GakrCLI/tree/main/assets/skills/architecture
Command: npx skills add https://github.com/gajjalaashok75-UI/GakrCLI --skill architecture-gajjalaashok75-ui

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps you make clear, defensible software architecture decisions when a system is getting harder to evolve, scale, or maintain. It guides you through understanding requirements, comparing options, and documenting the rationale behind major technical choices.

Core Features & Use Cases

  • Requirements Discovery: Gather scale, team, timeline, domain, and constraint details before choosing a design.
  • Pattern Selection: Choose between monolith, modular monolith, microservices, DDD, repository, event-driven, and API patterns based on real needs.
  • Trade-off Analysis: Evaluate alternatives, risks, consequences, and migration paths instead of defaulting to over-engineered solutions.
  • ADR Guidance: Document significant decisions in an Architecture Decision Record so the reasoning is traceable for future teams.
  • Use Case: A startup deciding whether to stay with a modular monolith or split into services can use this Skill to compare complexity, team fit, and scaling needs before committing.

Quick Start

Ask for an architecture recommendation for your system and include the team size, expected scale, timeline, domain complexity, and constraints.

Frequently Asked Questions about architecture

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

FAQPage Schema
How do I choose between a monolith and microservices for my system design?

System design pattern selection requires evaluating your team size, expected scale, timeline, and domain complexity. Comparing a monolith versus microservices involves analyzing trade-offs like operational impact and maintainability to avoid over-engineered solutions. You must gather these constraint details before committing to an architecture.

What is an Architecture Decision Record and when do I need one?

An Architecture Decision Record (ADR) documents the rationale, alternatives, and consequences behind significant technical choices so reasoning remains traceable for future teams. You need ADR guidance when making major pattern selections or trade-off decisions that impact system maintainability and scalability.

How do I perform trade-off analysis for software architecture decisions?

Architecture trade-off analysis evaluates alternatives, risks, consequences, and migration paths based on real requirements. Instead of defaulting to complex patterns, you compare options against scale, team fit, and domain constraints to produce defensible recommendations that balance maintainability and operational impact.

Can I use this for SaaS and enterprise architecture requirements discovery?

Requirements discovery applies to SaaS, enterprise, and MVP systems by gathering scale, team, timeline, and domain complexity details before choosing a design. It evaluates specific constraints to determine whether event-driven, DDD, repository, or API patterns suit your operational and scaling needs.

What is the best way to document system design decisions for a startup?

Documenting system design decisions involves capturing requirements, comparing architectural patterns, and recording the trade-off rationale in an ADR. This ensures a startup evaluating whether to stay with a modular monolith or split into services maintains traceable reasoning for future evolution and scaling.

When should I not use microservices for my architecture?

You should avoid microservices when requirements discovery indicates low domain complexity, small team size, or tight timelines that cannot support operational overhead. Architecture trade-off analysis helps identify when a modular monolith provides better maintainability without the distributed system complexity of event-driven services.