Guide Claude on creating Vaadin 25 views with @Route, setting up router layouts (AppLayout, @Layout), navigation between views, and passing data via URL parameters. This skill should be used when the user asks to "create a view", "add a route", "use @Route", "set up navigation", "use AppLayout", "build a navigation menu", "use SideNav", "pass data between views", "use route parameters", "use query parameters", "create a master-detail view", "use @Layout", "use RouterLayout", "use @ParentLayout", "use @RoutePrefix", "use @Menu", "use RouterLink", or "navigate programmatically". Also trigger when the user needs help choosing between route parameters and query parameters, building a MainLayout with a drawer and navigation menu, or structuring nested router layouts.
67
82%
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 a strong skill description that excels across all dimensions. It provides specific concrete capabilities for Vaadin 25 routing and navigation, includes an extensive list of natural trigger terms covering both user-friendly phrases and technical annotations, and clearly delineates both what the skill does and when it should be used. The Vaadin-specific terminology makes it highly distinctive and unlikely to conflict with other skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lists multiple specific concrete actions: creating views with @Route, setting up router layouts (AppLayout, @Layout), navigation between views, passing data via URL parameters, building a MainLayout with drawer and navigation menu, and structuring nested router layouts. | 3 / 3 |
Completeness | Clearly answers both 'what' (creating Vaadin 25 views, setting up router layouts, navigation, passing data via URL parameters) and 'when' with an extensive explicit 'Use when' clause listing numerous trigger phrases and scenarios. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms users would say, including both high-level phrases ('create a view', 'set up navigation', 'pass data between views') and specific technical terms ('@Route', 'AppLayout', 'SideNav', 'RouterLink', 'query parameters'). Covers many natural variations a user might use. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche: Vaadin 25 routing and navigation specifically. The combination of Vaadin-specific annotations (@Route, @Layout, @ParentLayout, @RoutePrefix, @Menu) and components (AppLayout, SideNav, RouterLink) makes it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
64%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, highly actionable skill with excellent executable code examples covering the full spectrum of Vaadin routing and navigation. Its main weaknesses are length (could be more concise by trimming explanatory prose and splitting detailed examples into referenced files) and the absence of explicit validation/error-handling guidance for common failure modes like invalid route parameters or misconfigured layouts. The referenced bundle file doesn't exist, slightly undermining the progressive disclosure structure.
Suggestions
Add validation/error-handling examples, such as using `event.rerouteToError()` or `event.forwardTo()` when route parameters are invalid, to improve workflow clarity for common failure scenarios.
Move the full MainLayout example and the master-detail pattern into `references/navigation-patterns.md` (or similar), keeping only concise summaries in the main skill to improve progressive disclosure and reduce token usage.
Trim explanatory prose like 'A Vaadin view is a Java class annotated with @Route that extends Component or any subclass' and the RouterLayout interface description — Claude knows these concepts and can infer them from the code examples.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is comprehensive and mostly well-written, but it's quite long (~350+ lines) with some sections that could be tightened. The 'When to Use This Skill vs. Others' section and some explanatory prose (e.g., explaining what RouterLayout provides, what AppLayout is) add tokens that Claude likely doesn't need. The best practices and anti-patterns sections, while useful, include some obvious guidance. However, it avoids egregious over-explanation of basic concepts. | 2 / 3 |
Actionability | Excellent actionability throughout. Every concept is accompanied by complete, executable Java code examples — from basic @Route usage to a full production-ready MainLayout, master-detail pattern, route templates with regex constraints, and the 'Your Own API' pattern. Code is copy-paste ready with proper imports shown where needed. The decision table for parameter approaches is particularly actionable. | 3 / 3 |
Workflow Clarity | The skill covers many patterns clearly but lacks explicit validation checkpoints or feedback loops. For example, the master-detail pattern doesn't mention what happens when an invalid ID is passed (no error handling/rerouting shown). The nested layouts section doesn't warn about common pitfalls in route resolution order. There's no 'verify your setup' step after creating a MainLayout. For a skill involving route configuration where misconfigurations can cause silent failures, validation steps would be valuable. | 2 / 3 |
Progressive Disclosure | The skill references `references/navigation-patterns.md` at the end and mentions other skills (vaadin-layouts, client-side-views, reusable-components) for cross-referencing, which is good. However, no bundle files were provided, so the reference may not exist. The main content itself is quite long and monolithic — sections like the full MainLayout example, master-detail pattern, and the extensive best practices/anti-patterns could potentially be split into referenced files to keep the main skill leaner. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
81%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 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (587 lines); consider splitting into references/ and linking | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
e47fdfe
Table of Contents
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.