skills.rest
pluginagentmarketplace
pluginagentmarketplaceCOMMUNITY
Explore all skills by this author →
GitHub

architecture

Design scalable Linux system architectures using reusable patterns and templates.

3|Updated Nov 18, 2025
Search Tags:#architecture#documentation#scalability#patterns#reliability#Linux#systems-design
One-click install
npx skills add https://github.com/pluginagentmarketplace/custom-plugin-linux --skill architecture-pluginagentmarketplace
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture
Source: https://github.com/pluginagentmarketplace/custom-plugin-linux/tree/main/skills/architecture
Command: npx skills add https://github.com/pluginagentmarketplace/custom-plugin-linux --skill architecture-pluginagentmarketplace

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires pyyaml, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

Linux system architects and DevOps teams struggle to design and evolve scalable, reliable architectures. This Skill provides a structured framework that codifies architecture patterns, templates, and decision logs to streamline planning and communication.

Core Features & Use Cases

  • Pattern-driven design: Microservices, event-driven patterns, CQRS, and fault tolerance.
  • System design templates: Steps for requirements, capacity estimation, high-level design, and detailed component design.
  • Real-world scenarios: Planning a scalable Linux infrastructure for a startup, a growth-stage platform, or on-premises data center migrations.

Quick Start

Use the architecture skill to outline a scalable Linux design by providing goals, constraints, and proposed components.

Frequently Asked Questions about architecture

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

FAQPage Schema
How do I design scalable Linux architectures for a growth-stage platform?▼

Design scalable Linux architectures by applying reusable patterns like microservices, event-driven design, and CQRS. The skill provides structured templates for capacity estimation and high-level component design to handle growth-stage platform demands.

What patterns are available for fault tolerance and reliable systems design?▼

For reliable systems design, the skill provides fault tolerance patterns, reliability practices, and event-driven design templates. These reusable patterns codify decision logs to streamline planning and communication for complex Linux infrastructure.

Can I use these architecture templates for on-premises data center migrations?▼

Yes, the architecture templates support on-premises data center migrations by providing structured steps for requirements gathering, capacity estimation, and detailed component design. Scenarios cover startups, growth-stage platforms, and enterprise migrations.

How do I structure capacity estimation and component design for Linux infrastructure?▼

Structure capacity estimation and component design by following the skill's system design templates. These templates guide you through requirements, high-level design, and detailed component design steps tailored for scalable Linux infrastructure.

What's the best way to document architecture decisions for microservices and event-driven systems?▼

Document architecture decisions using the skill's formal framework, which codifies patterns and decision logs for microservices and event-driven systems. This streamlines communication and planning across DevOps teams from startup to enterprise scale.

Related Skills

Explore More Software Engineering Skills→
Tristan578Tristan578
5

architect-flow

Plan SpawnForge feature architecture specs with JSON event schemas and Bevy systems.

Community
Advanced
v1bh0rv1bh0r

nw-devops

Plan platform readiness and infrastructure design for feature deployments.

Community
Advanced
RaheesAhmedRaheesAhmed
66

architect

Evaluate architectural patterns and generate ADRs for scalable systems.

Community
Advanced
jvegafjvegaf
17

architecture-designer

Design and review system architectures with microservices and event-driven patterns.

Community
Advanced