controller-patterns
Review and update existing Rails controllers and generate new controllers following professional patterns and best practices. Covers RESTful conventions, authorization patterns, proper error handling, and maintainable code organization.
50
56%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/controller-patterns/SKILL.mdQuality
Discovery
50%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description adequately identifies its domain (Rails controllers) and lists relevant concerns, but lacks the explicit 'Use when...' trigger clause needed for Claude to confidently select this skill. The capabilities described are more categorical than concrete, and the trigger terms, while relevant, miss common user vocabulary variations.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user asks about Rails controllers, adding controller actions, RESTful routes, strong parameters, or before_action callbacks.'
Include more natural trigger terms users would say, such as 'CRUD', 'strong params', 'before_action', 'scaffold controller', 'controller specs', or specific file patterns like 'app/controllers/'.
Make capabilities more concrete by listing specific actions, e.g., 'Set up strong parameters, add before_action callbacks, implement Pundit/CanCanCan authorization, structure concerns for shared behavior.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Rails controllers) and lists some actions ('review and update', 'generate new controllers'), plus mentions specific concerns like RESTful conventions, authorization patterns, error handling, and code organization. However, these are more categories than concrete actions—it doesn't specify things like 'add before_action callbacks', 'implement strong parameters', or 'set up resource routing'. | 2 / 3 |
Completeness | The 'what' is reasonably covered (review/update/generate Rails controllers with best practices), but there is no explicit 'Use when...' clause or equivalent trigger guidance. The 'when' is only implied by the description of capabilities, which caps this at 2 per the rubric guidelines. | 2 / 3 |
Trigger Term Quality | Includes relevant terms like 'Rails controllers', 'RESTful', 'authorization', and 'error handling' which users might mention. However, it misses common variations and natural phrases users would say such as 'controller action', 'routes', 'before_action', 'strong params', 'scaffold', or 'CRUD'. | 2 / 3 |
Distinctiveness Conflict Risk | It's specific to Rails controllers, which provides some distinctiveness. However, it could overlap with general Rails skills, Ruby code review skills, or broader web framework skills. Terms like 'authorization patterns' and 'error handling' are generic enough to conflict with non-controller-specific skills. | 2 / 3 |
Total | 8 / 12 Passed |
Implementation
62%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill provides highly actionable, executable Rails controller patterns with good workflow guidance through its decision tree and review checklist. However, it suffers significantly from redundancy — the same CRUD controller pattern appears three times in slightly different forms, and many sections explain concepts Claude already knows (RESTful actions, naming conventions, basic strong parameters). The content would benefit greatly from aggressive deduplication and splitting advanced patterns into separate referenced files.
Suggestions
Eliminate redundancy by showing the CRUD controller pattern only once (in Quick Reference) and removing the duplicate in 'RESTful Action Patterns' and 'Complete Examples' sections — or move complete examples to a separate EXAMPLES.md file.
Remove explanations of concepts Claude already knows, such as individual RESTful action descriptions (index lists resources, show displays one, etc.), basic naming conventions, and HTTP status code definitions.
Extract Advanced Patterns (state controllers, bulk operations, complex nested attributes) into a separate ADVANCED_PATTERNS.md file and reference it from the main skill to improve progressive disclosure.
Consolidate the 'Essential Patterns' rules lists — many repeat what's already shown in the code examples (e.g., 'Use policy_scope() for collections' is self-evident from the code).
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is extremely verbose at ~400+ lines with significant redundancy. The 'Standard CRUD Controller' pattern is shown in full three times (Quick Reference, RESTful Action Patterns broken out individually, and Complete Examples). Each RESTful action is explained separately despite Claude knowing Rails conventions. Authorization rules, before_action patterns, and strong parameters are all concepts Claude already understands well. | 1 / 3 |
Actionability | All code examples are fully executable, copy-paste ready Ruby with correct syntax. The patterns include complete controller files, route definitions, and view helpers. The strong parameters examples show real nested attribute patterns with proper syntax. | 3 / 3 |
Workflow Clarity | The decision tree clearly guides which pattern to use. The Agent Instructions section provides a clear numbered sequence for generating controllers and a checklist for reviewing existing ones with prioritized ordering. State validation patterns include explicit guard clauses with early returns. | 3 / 3 |
Progressive Disclosure | The content is well-organized with clear sections and a logical progression from quick reference to advanced patterns. However, it's monolithic — the advanced patterns (state controllers, bulk operations) and complete examples could be split into separate files to reduce the main skill's size. No bundle files are referenced or provided. | 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 (641 lines); consider splitting into references/ and linking | Warning |
metadata_version | 'metadata.version' is missing | Warning |
Total | 9 / 11 Passed | |
- Repository
- RoleModel/rolemodel-skills
- Commit
72e8136
- 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.