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.