microservices-patterns
Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.
80
54%
Does it follow best practices?
Impact
97%
1.42xAverage score across 6 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/backend-development/skills/microservices-patterns/SKILL.mdQuality
Discovery
82%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 a solid description that clearly communicates both what the skill does and when to use it, with good trigger term coverage for the microservices domain. Its main weakness is that the capabilities listed are somewhat conceptual rather than concrete discrete actions, and terms like 'distributed systems' could cause overlap with adjacent architecture skills.
Suggestions
Make capabilities more concrete by listing specific deliverables, e.g., 'Define service boundaries, design API contracts, configure circuit breakers, plan event schemas, create service dependency diagrams'.
Improve distinctiveness by clarifying what differentiates this from general architecture or cloud infrastructure skills, e.g., specifying it focuses on application-level service decomposition rather than infrastructure provisioning.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (microservices) and some actions ('design architectures', 'service boundaries', 'event-driven communication', 'resilience patterns'), but these are more like architectural concepts than concrete discrete actions. Compare to the level 3 example which lists very specific operations like 'extract text', 'fill forms', 'merge documents'. | 2 / 3 |
Completeness | Clearly answers both 'what' (design microservices architectures with service boundaries, event-driven communication, and resilience patterns) and 'when' (use when building distributed systems, decomposing monoliths, or implementing microservices) with an explicit 'Use when...' clause. | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'microservices', 'distributed systems', 'decomposing monoliths', 'service boundaries', 'event-driven', 'resilience patterns'. These cover the main terms a user working in this domain would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | While 'microservices' is a fairly specific domain, terms like 'distributed systems' and 'resilience patterns' could overlap with skills focused on general system design, cloud architecture, or infrastructure. The description could be more distinctive by specifying unique deliverables or differentiating from broader architecture skills. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
27%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill reads more like a textbook chapter on microservices than an actionable skill for Claude. It is excessively verbose with redundant conceptual sections (Core Concepts duplicates the detailed sections), relies on incomplete/non-executable code with many undefined types, and dumps everything into a single monolithic file. The architectural patterns shown are reasonable but would benefit greatly from being condensed and restructured.
Suggestions
Remove the entire 'Core Concepts' section — it duplicates the detailed patterns below and explains things Claude already knows (what REST is, what a circuit breaker does conceptually).
Split detailed pattern implementations (Circuit Breaker, Saga, Event Bus, API Gateway) into separate reference files and keep only a concise overview with links in the main SKILL.md.
Make code examples more executable by either defining the missing types (StepResult, SagaResult, Order, etc.) or simplifying to self-contained examples that can actually run.
Add a workflow section with concrete steps for when Claude is asked to design a microservices architecture — e.g., 1) Identify bounded contexts, 2) Define service contracts, 3) Choose communication pattern, 4) Validate with specific criteria.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~400+ lines. The 'Core Concepts' section is entirely redundant with the detailed patterns that follow, and much of it explains concepts Claude already knows (what REST/gRPC/GraphQL are, what circuit breakers do conceptually). The bullet-point summaries before each code section add little value. | 1 / 3 |
Actionability | Code examples are fairly detailed and illustrative, but they rely on undefined types (Order, PaymentRequest, StepResult, SagaResult, etc.) and undefined service objects, making them not truly executable. They serve more as architectural templates/pseudocode than copy-paste ready implementations. | 2 / 3 |
Workflow Clarity | The Saga pattern shows a clear multi-step process with compensation/rollback, which is good. However, there's no guidance on how to actually set up, validate, or test a microservices architecture — no deployment workflow, no validation checkpoints for verifying service boundaries or communication works correctly. | 2 / 3 |
Progressive Disclosure | This is a monolithic wall of text with no references to external files. All patterns are inlined in a single massive document. Content like the Circuit Breaker implementation, Saga pattern, and Event Bus could easily be split into separate reference files with a concise overview in the main skill. | 1 / 3 |
Total | 6 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (565 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- wshobson/agents
- Commit
70444e5
- 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.