software-engineering-eng-distributed

Guide distributed system design and review for correctness under partitions, failures, and retries.

Updated May 6, 2025
One-click install
npx skills add https://github.com/rodrigo-altissimo/qiartificial --skill software-engineering-eng-distributed
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-engineering-eng-distributed
Source: https://github.com/rodrigo-altissimo/qiartificial/tree/main/.claude/skills/software-engineering/eng-distributed
Command: npx skills add https://github.com/rodrigo-altissimo/qiartificial --skill software-engineering-eng-distributed

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you reason rigorously about distributed system trade-offs—so you can design architectures that behave correctly under partitions, failures, and retries.

Core Features & Use Cases

  • Consistency, CAP, and failure-mode analysis: Identify per-entity consistency requirements and predict behavior under network partitions and common failure modes.
  • Replication and partitioning strategy: Choose replication topology (single-leader, multi-leader, leaderless) and partition keys (range, hash, rebalancing) to match your scale and correctness needs.
  • Operational design for correctness: Apply idempotency, delivery semantics, stream-processing considerations, and distributed design patterns like event sourcing, CQRS, and sagas.

Use case example: You’re reviewing a Kafka-based payments/order pipeline and need to determine the correct delivery semantics, ordering guarantees, idempotency approach, and the consistency model for each data entity—then produce concrete recommendations and failure-mode mitigations.

Quick Start

Ask the skill to analyze a distributed system you describe and to return a failure-mode catalog, a consistency/partitioning strategy, and top corrective recommendations.

Frequently Asked Questions about software-engineering-eng-distributed

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

FAQPage Schema
How do I design a distributed system that handles network partitions correctly?

Designing distributed systems for network partitions requires explicit CAP theorem reasoning to identify per-entity consistency requirements and predict system behavior under failures. You must analyze consistency models, replication topologies, and failure modes to ensure correctness during partitions.

What is the best way to choose between single-leader and leaderless replication for my architecture?

Choosing between single-leader, multi-leader, and leaderless replication depends on your specific scale and correctness needs. Evaluate your consistency requirements and failure-mode tolerances to select a replication topology that matches your expected write conflicts and partition behavior.

How do I ensure idempotency and correct delivery semantics in a Kafka stream processing pipeline?

Ensuring idempotency and correct delivery semantics in stream processing requires aligning your consistency model with ordering guarantees for each data entity. You must analyze the pipeline's failure modes and apply appropriate distributed design patterns to prevent duplicate processing.

When do I need to apply event sourcing, CQRS, or sagas in distributed transaction patterns?

You need to apply event sourcing, CQRS, or sagas when your distributed system requires operational design correctness across complex retries and partitions. These patterns help manage distributed transactions by decoupling state changes and enabling reliable event-driven workflows.

What partitioning strategy should I use for distributed data rebalancing?

Your partitioning strategy should match your scale and correctness needs by choosing appropriate partition keys for range or hash-based distribution. Proper partition key selection minimizes hotspots and ensures efficient data rebalancing during cluster changes.

Can I use this approach for architecture review of existing distributed systems?

Yes, this approach applies directly to architecture review and troubleshooting of existing distributed systems. It enables you to evaluate consistency models, replication topologies, and delivery semantics to produce concrete corrective recommendations and failure-mode mitigations.