saga-orchestration
Implement saga patterns for distributed transactions and cross-aggregate workflows. Use this skill when implementing distributed transactions across microservices where 2PC is unavailable, designing compensating actions for failed order workflows that span inventory, payment, and shipping services, building event-driven saga coordinators for travel booking systems that must roll back hotel, flight, and car rental reservations atomically, or debugging stuck saga states in production where compensation steps never complete.
71
86%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is an excellent skill description that clearly defines a specific niche (saga patterns for distributed transactions), lists concrete actions and scenarios, and provides explicit trigger guidance with a 'Use this skill when...' clause. The description uses appropriate third-person voice and includes rich, natural trigger terms that developers would actually use when seeking help with this topic.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: implementing distributed transactions, designing compensating actions for order workflows, building event-driven saga coordinators for travel booking, and debugging stuck saga states. Mentions specific domains like inventory, payment, shipping, hotel, flight, and car rental reservations. | 3 / 3 |
Completeness | Clearly answers both 'what' (implement saga patterns for distributed transactions and cross-aggregate workflows) and 'when' with an explicit 'Use this skill when...' clause listing four detailed trigger scenarios. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms a user would say: 'saga', 'distributed transactions', '2PC', 'compensating actions', 'microservices', 'event-driven', 'saga coordinator', 'roll back', 'compensation steps', 'stuck saga states'. These are the exact terms developers use when dealing with this pattern. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive niche focused specifically on saga patterns and distributed transaction coordination. The specific mention of saga coordinators, compensating actions, 2PC alternatives, and cross-service workflows makes it very unlikely to conflict with general microservice or event-driven architecture skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
72%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a strong skill with excellent actionability through three concrete, executable Python templates and a thorough troubleshooting section. The main weaknesses are moderate verbosity in the conceptual sections (explaining saga patterns Claude already knows) and the lack of an explicit step-by-step implementation workflow with validation checkpoints. The progressive disclosure is well-structured with appropriate use of references.
Suggestions
Trim or remove the 'Core Concepts' section (saga pattern types, execution states) — Claude already knows these; keep only the compensation rules table as it contains actionable decision logic.
Add an explicit implementation workflow section with numbered steps and validation checkpoints, e.g., '1. Define steps → 2. Implement participants → 3. Test each compensation path by injecting failure at step N → 4. Verify reverse-order compensation → 5. Add timeout configuration'.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but includes some unnecessary content. The 'Core Concepts' section with the ASCII diagram and state table explains saga patterns that Claude likely already knows. The 'When to Use This Skill' section largely restates the description. However, the templates and troubleshooting sections are well-targeted and earn their tokens. | 2 / 3 |
Actionability | The skill provides three fully executable Python templates covering orchestration, choreography, and idempotency guards. Code is concrete with realistic class structures, event handling, and error handling patterns. The troubleshooting section pairs each problem with specific code fixes or architectural guidance. | 3 / 3 |
Workflow Clarity | The saga execution states and compensation rules tables provide good conceptual clarity, and the troubleshooting section addresses common failure modes with fixes. However, there is no explicit step-by-step workflow for implementing a saga from scratch (e.g., 'first define steps, then implement participants, then validate compensation paths'). The compensation retry → DLQ → manual intervention path is mentioned but not shown as a concrete validation checkpoint in a workflow. | 2 / 3 |
Progressive Disclosure | The skill provides a clear overview with templates inline for immediate use, and appropriately defers advanced content (full base class, timeout orchestrator, Prometheus instrumentation, DLQ recovery worker) to `references/advanced-patterns.md`. References are one level deep and clearly signaled. Related skills are listed for cross-referencing. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- wshobson/agents
- Commit
112197c
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.