system

Analyze distributed system architectures for reliability patterns and anti-patterns.

3|Updated May 12, 2026
One-click install
npx skills add https://github.com/gao-hongnan/omniagents --skill system-gao-hongnan
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: system
Source: https://github.com/gao-hongnan/omniagents/tree/main/plugins/design-patterns/skills/system
Command: npx skills add https://github.com/gao-hongnan/omniagents --skill system-gao-hongnan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a rigorous framework for designing and reviewing complex, cross-service system architectures, helping you avoid common pitfalls like cascading failures and distributed monoliths.

Core Features & Use Cases

  • Reliability Patterns: Implement timeouts, retries, circuit breakers, and bulkheads to ensure system resilience.
  • Distributed Coordination: Navigate complex patterns like Sagas, Raft, and distributed locks with strict-typed Python examples.
  • Use Case: When designing a new microservice, use this Skill to determine the optimal communication pattern (e.g., sync vs. async) and identify potential anti-patterns before they reach production.

Quick Start

Use the system skill to review the proposed architecture for the new order processing service against the distributed monolith anti-pattern.

Frequently Asked Questions about system

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

FAQPage Schema
How do I prevent cascading failures when designing distributed systems?▼

To prevent cascading failures in distributed systems, apply reliability patterns such as timeouts, retries, circuit breakers, and bulkheads. This Skill provides strict-typed Python 3.13+ implementation sketches to enforce system resilience.

What are common microservices anti-patterns I should look for during a system design review?▼

A common microservices anti-pattern is the distributed monolith, where tight cross-service coupling undermines independence. This Skill reviews architectures for such pitfalls, evaluating communication and data consistency strategies before production.

How do I choose between sync and async communication patterns for a new microservice?▼

Choosing between sync and async communication patterns depends on your reliability and data consistency requirements. This Skill analyzes architectural patterns and provides strict-typed Python examples to help determine the optimal distributed coordination strategy.

How does the Saga pattern work for distributed coordination in microservices?▼

The Saga pattern manages distributed coordination by sequencing local transactions with compensating actions to maintain data consistency. This Skill provides strict-typed Python 3.13+ definitions for Sagas, Raft, and distributed locks.

Can I use this Skill to review regional and operator-facing system architectures?▼

Yes, this Skill supports design reviews for regional and operator-facing system architectures. It evaluates cross-service shapes and enforces strict-typed Python 3.13+ standards for all pattern definitions and implementation sketches.

When should I not use synchronous communication in distributed systems?▼

Avoid synchronous communication in distributed systems when it risks tight cross-service coupling or cascading failures. This Skill analyzes architectural anti-patterns and provides alternative reliability strategies to mitigate such risks.