spring-boot-event-driven-patterns
Implement Event-Driven Architecture (EDA) in Spring Boot using ApplicationEvent, @EventListener, and Kafka. Use for building loosely-coupled microservices with domain events, transactional event listeners, and distributed messaging patterns.
Install with Tessl CLI
npx tessl i github:giuseppe-trisciuoglio/developer-kit --skill spring-boot-event-driven-patternsOverall
score
82%
Does it follow best practices?
If you maintain this skill, you can automatically optimize it using the tessl CLI to improve its score:
npx tessl skill review --optimize ./path/to/skillValidation for skill structure
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 a strong skill description that clearly identifies its domain (Spring Boot event-driven architecture), lists specific technologies and patterns, and provides explicit usage guidance. The description uses proper third-person voice and includes both common acronyms (EDA) and full terminology that users would naturally use when seeking this functionality.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and technologies: 'ApplicationEvent, @EventListener, and Kafka' and specific patterns like 'domain events, transactional event listeners, and distributed messaging patterns'. | 3 / 3 |
Completeness | Clearly answers both what ('Implement Event-Driven Architecture using ApplicationEvent, @EventListener, and Kafka') and when ('Use for building loosely-coupled microservices with domain events, transactional event listeners, and distributed messaging patterns'). | 3 / 3 |
Trigger Term Quality | Includes natural keywords users would say: 'Event-Driven Architecture', 'EDA', 'Spring Boot', 'Kafka', 'microservices', 'domain events', '@EventListener', 'ApplicationEvent' - good coverage of both acronyms and full terms. | 3 / 3 |
Distinctiveness Conflict Risk | Clear niche combining Spring Boot + event-driven architecture + Kafka - unlikely to conflict with general Spring skills or general Kafka skills due to the specific intersection of technologies and patterns mentioned. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
73%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a comprehensive skill with excellent actionability - all code examples are complete and executable. The main weaknesses are verbosity (especially in setup sections and the 'When to Use' list) and missing explicit validation workflows for multi-step operations like event publishing and outbox processing. The progressive disclosure is well-handled with clear navigation to reference materials.
Suggestions
Remove or significantly condense the 'When to Use This Skill' section - Claude can infer appropriate use cases from the patterns themselves
Remove inline comments in dependency blocks that explain what each dependency does (e.g., '// Spring Boot Web') - this is obvious
Add explicit validation steps to the outbox pattern workflow, such as 'Verify event in outbox table -> Check Kafka topic -> Confirm publishedAt timestamp updated'
Consider moving the full Maven/Gradle dependency blocks to a reference file and keeping only essential dependencies inline
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary explanations (e.g., 'When to Use This Skill' section is verbose, comments in dependency blocks explaining what each dependency is for). The content could be tightened significantly while preserving all actionable information. | 2 / 3 |
Actionability | Provides fully executable, copy-paste ready code examples throughout - from domain events to aggregate roots, event handlers, Kafka publishers, and integration tests. All code is complete and specific. | 3 / 3 |
Workflow Clarity | While the patterns are well-organized, there's no explicit validation workflow or feedback loops. For example, the outbox pattern shows retry logic but doesn't provide clear steps for verifying event delivery or debugging failed events in sequence. | 2 / 3 |
Progressive Disclosure | Good structure with clear sections progressing from setup to core patterns to advanced patterns. References to external files (examples.md, event-driven-patterns-reference.md) are one level deep and clearly signaled. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
56%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 16 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (520 lines); consider splitting into references/ and linking | Warning |
description_trigger_hint | Description may be missing an explicit 'when to use' trigger hint (e.g., 'Use when...') | Warning |
allowed_tools_field | 'allowed-tools' contains unusual tool name(s) | Warning |
metadata_version | 'metadata' field is not a dictionary | Warning |
license_field | 'license' field is missing | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
body_steps | No step-by-step structure detected (no ordered list); consider adding a simple workflow | Warning |
Total | 9 / 16 Passed | |
- 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.