architecture-designer

Name: architecture-designer
Availability: InStock
Author: hyagoviana

Design high-level system architectures with patterns, diagrams, and ADRs.

1|Updated May 15, 2026

Search Tags:#scalability #microservices #adr #architecture-design #non-functional-requirements #system-diagramming #technology-tradeoffs

Ready to run

npx skills add https://github.com/hyagoviana/Sistema_Hyago_Viana_Adabtech --skill architecture-designer-hyagoviana

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: architecture-designer
Source: https://github.com/hyagoviana/Sistema_Hyago_Viana_Adabtech/tree/main/.agents/skills/architecture-designer
Command: npx skills add https://github.com/hyagoviana/Sistema_Hyago_Viana_Adabtech --skill architecture-designer-hyagoviana

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you create and validate high-level system architecture decisions that balance scalability, maintainability, and operational reality.

Core Features & Use Cases

Architecture design workflow: turn requirements (functional and non-functional) into a coherent architecture with explicit trade-offs.
ADRs (Architecture Decision Records): document key decisions, alternatives considered, and consequences for long-term traceability.
Pattern-guided structuring: choose architectural patterns (monolith, modular monolith, microservices, serverless, event-driven, CQRS) aligned to the problem.
Output-ready artifacts: produce a Mermaid architecture diagram plus a set of ADRs, risks, and mitigations.

Quick Start

Use the architecture-designer skill to draft a high-level architecture and ADR set for a scalable microservices platform based on the provided requirements.

Frequently Asked Questions about architecture-designer

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

FAQPage Schema

How do I design scalable system architecture with clear technology trade-offs?▼

Designing scalable system architecture with clear trade-offs requires structuring high-level decisions using patterns, diagrams, and Architecture Decision Records. This approach reduces uncertainty in system structuring while explicitly balancing maintainability and operational reality.

When do I need Architecture Decision Records for microservices decomposition?▼

You need Architecture Decision Records for microservices decomposition to document key decisions, alternatives considered, and consequences. ADRs ensure long-term traceability and satisfy the need for explicit trade-off documentation during architecture reviews.

What is the best way to map non-functional requirements to infrastructure patterns?▼

The best way to map non-functional requirements to infrastructure patterns is through pattern-guided structuring. This method aligns architectural patterns like serverless or event-driven systems directly to the operational and security considerations of your specific problem.

Can I generate Mermaid system diagrams from functional and non-functional requirements?▼

Yes, you can generate Mermaid system diagrams from functional and non-functional requirements. The architecture design workflow turns requirements into a coherent architecture, producing output-ready artifacts like Mermaid diagrams alongside ADRs and risk mitigations.

Does this approach work for both monolith and microservices scalability planning?▼

Yes, this approach works for both monolith and microservices scalability planning. Pattern-guided structuring helps you choose appropriate architectural patterns, including modular monoliths, microservices, CQRS, and event-driven designs, based on your specific operational requirements.

Why should I not use microservices architecture for every new system design?▼

You should not use microservices for every new system design because it introduces operational complexity. Choosing architectural patterns aligned to the problem ensures you capture necessary technology trade-offs, potentially selecting a modular monolith or serverless approach instead.