sandi-metz-rules
This skill should be used when users request code review, refactoring, or code quality improvements for Ruby codebases. Apply Sandi Metz's four rules for writing maintainable object-oriented code - classes under 100 lines, methods under 5 lines, no more than 4 parameters, and controllers instantiate only one object. Use when users mention "Sandi Metz", "code quality", "refactoring", or when reviewing Ruby code for maintainability.
79
67%
Does it follow best practices?
Impact
100%
1.17xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/sandi-metz-rules/SKILL.mdQuality
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 defines its scope (Sandi Metz's four rules for Ruby code), lists concrete actions and criteria, and provides explicit trigger guidance. It uses third person voice appropriately and includes both domain-specific and natural language trigger terms. The description is concise yet comprehensive, making it easy for Claude to distinguish this skill from general code review or other language-specific skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and rules: classes under 100 lines, methods under 5 lines, no more than 4 parameters, controllers instantiate only one object. Also names code review, refactoring, and code quality improvements as concrete actions. | 3 / 3 |
Completeness | Clearly answers both 'what' (applies Sandi Metz's four rules for maintainable OO code in Ruby, with specific rule details) and 'when' (explicit 'Use when' clause with trigger terms like 'Sandi Metz', 'code quality', 'refactoring', or reviewing Ruby code). | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would say: 'Sandi Metz', 'code quality', 'refactoring', 'Ruby', 'code review', 'maintainability'. These cover common variations of how users would phrase requests in this domain. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive due to the specific focus on Sandi Metz's rules, Ruby codebases, and the named four rules. This is unlikely to conflict with generic code review skills or other language-specific skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is well-structured and covers the topic comprehensively, but suffers significantly from verbosity—it explains many concepts Claude already knows (design patterns, SRP, what code smells are) and includes abstract guidance rather than concrete examples. The code counting rules and RuboCop configuration are the strongest sections. The skill would benefit greatly from cutting ~60% of the content and replacing abstract refactoring descriptions with concrete before/after Ruby code examples.
Suggestions
Cut the 'When to Use This Skill' section entirely (duplicates YAML metadata) and remove explanations of well-known concepts like SRP, design patterns, and what code smells are.
Replace the abstract refactoring strategy lists (e.g., 'Extract related methods into new classes') with 2-3 concrete before/after Ruby code examples showing actual refactorings.
Move the detailed prioritization guidance, automation configuration, and usage patterns into references/rules.md to keep SKILL.md as a lean overview.
Add explicit validation checkpoints in the workflow, such as running RuboCop after refactoring to verify compliance and running the test suite with a specific command.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~180+ lines. Explains concepts Claude already knows (what Sandi Metz's rules are, what SRP is, what design patterns are). The 'When to Use This Skill' section repeats the YAML description. Sections like 'Consider Context' and 'Prioritize Issues' describe general code review knowledge Claude already possesses. The entire content could be reduced to ~40 lines without losing actionable value. | 1 / 3 |
Actionability | The code counting rules with Ruby examples are concrete and useful, and the RuboCop configuration is copy-paste ready. However, the refactoring suggestions are abstract descriptions ('Extract related methods into new classes', 'Apply patterns: Strategy, Decorator, Command, Facade') rather than concrete before/after Ruby code examples. The skill tells Claude to 'show before and after code examples' but doesn't actually provide any. | 2 / 3 |
Workflow Clarity | The workflow has clear numbered steps for different patterns (full codebase review, specific file review, refactoring assistance), but lacks validation checkpoints. Step 4 in Pattern 3 says 'Verify that tests still pass' but doesn't specify how. There are no feedback loops for when refactoring introduces issues or when violations are ambiguous. | 2 / 3 |
Progressive Disclosure | References 'references/rules.md' appropriately and the navigation is one level deep, which is good. However, no bundle files were provided, so we can't verify the reference exists. More importantly, a large amount of content that could be in the reference file (detailed refactoring strategies, prioritization guidance, automation config) is inlined in the SKILL.md, making it bloated rather than serving as a concise overview. | 2 / 3 |
Total | 7 / 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
- lucianghinda/superpowers-ruby
- Commit
c037ce3
- 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.