software-architecture

Design scalable software architectures with pattern guidance, ADR templates, and trade-off analyses.

11|1|Updated Jan 16, 2026
One-click install
npx skills add https://github.com/sunnypatneedi/claude-starter-kit --skill software-architecture-sunnypatneedi
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-architecture
Source: https://github.com/sunnypatneedi/claude-starter-kit/tree/main/skills/engineering/software-architecture
Command: npx skills add https://github.com/sunnypatneedi/claude-starter-kit --skill software-architecture-sunnypatneedi

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing scalable software architectures is a complex challenge; teams require proven patterns, ADR templates, and a clear decision framework to align stakeholders and outcomes.

Core Features & Use Cases

  • Pattern guidance (MVC, microservices, event-driven) to select the right architecture for a project.
  • ADR generation and decision tracking to document architectural choices and rationale.
  • Trade-off analysis and technology stack recommendations for evolving, multi-team systems.

Quick Start

Generate an ADR-driven architecture plan for a new web app, including pattern choice (e.g., microservices vs monolith), recommended tech stack, and an initial ADR set.

Frequently Asked Questions about software-architecture

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

FAQPage Schema
How do I choose between microservices and monolith architecture for a new project?

To choose your software architecture, you need a trade-off analysis comparing microservices and monolith patterns based on scalability needs. This approach evaluates your project requirements and team structure to recommend the right architecture pattern and technology stack.

What is an ADR and when do I need one for software design?

An ADR (Architecture Decision Record) is a document capturing architectural choices and their rationale. You need ADRs when making multi-team architecture decisions or monolith refactors, ensuring stakeholders align on design outcomes and trade-offs.

How do I generate an architecture plan for a scalable web app?

You generate an architecture plan by selecting a pattern like MVC, microservices, or event-driven, then defining a technology stack. This produces an ADR-driven plan documenting your architectural choices and enforcing SOLID principles.

Does this architecture design approach work for monolith refactoring?

Yes, this architecture design approach supports monolith refactoring by applying architectural best practices and SOLID principles. It provides pattern guidance and decision tracking to guide multi-team architecture decisions during the refactor.

What's the best way to document trade-off analysis for multi-team systems?

The best way to document trade-off analysis is using ADR templates to record architectural choices and rationale. This framework aligns multi-team stakeholders on technology stack recommendations and evolving system decisions.

When should I not use microservices architecture?

You should avoid microservices architecture when a trade-off analysis reveals insufficient team scaling needs or complexity overhead. Using ADR templates to document these architectural decisions ensures you select the right pattern, such as MVC or monolith.