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 an excellent skill description that clearly articulates what it does (applies Sandi Metz's four specific rules for Ruby code quality), when to use it (explicit trigger terms and use-case guidance), and is highly distinctive due to its named methodology and language focus. The description is concise yet comprehensive, with strong natural trigger terms and no vague fluff.
| 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) and 'when' (explicit 'Use when' clause with trigger terms like 'Sandi Metz', 'code quality', 'refactoring', or reviewing Ruby code for maintainability). | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would actually 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 enumerated constraints. Unlikely to conflict with generic code review or refactoring skills because of the named methodology and language specificity. | 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 it is significantly over-verbose for its purpose. Much of the content — refactoring patterns, design principles, when to break rules — is knowledge Claude already possesses about Ruby and OOP. The most valuable parts are the precise code counting rules and the RuboCop configuration, but the skill would benefit greatly from trimming general knowledge and adding concrete before/after refactoring examples.
Suggestions
Cut sections that restate Claude's existing knowledge (refactoring strategies like 'use composition', 'apply Strategy pattern', context exceptions like 'test files should be readable') and reduce the body to novel, project-specific guidance.
Add at least one concrete before/after Ruby code example showing a violation being refactored, rather than just listing abstract strategies.
Add a validation checkpoint after refactoring steps — e.g., 're-run the counting rules on refactored code to confirm all four rules pass' — to create a feedback loop.
Move the detailed refactoring strategies and automation configuration into the referenced 'references/rules.md' file to keep SKILL.md as a lean overview.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Significantly verbose. The 'When to Use This Skill' section repeats the YAML description. Sections like 'Overview' explain what the rules are for (Claude already knows Sandi Metz's rules). The prioritization tiers, usage patterns, and refactoring strategies are largely things Claude already knows about Ruby refactoring. The 'Consider Context' section lists obvious exceptions. Much of this content doesn't add novel information beyond what Claude already possesses. | 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 strategies are abstract lists (e.g., 'Extract related methods into new classes', 'Apply patterns: Strategy, Decorator, Command, Facade') rather than concrete before/after code examples. The workflow says 'Show before and after code examples' but doesn't actually include any. | 2 / 3 |
Workflow Clarity | The workflow has clear numbered steps and multiple usage patterns (full codebase, specific file, refactoring assistance). However, there are no validation checkpoints or feedback loops — for instance, after refactoring there's no step to re-check that the refactored code still satisfies all four rules, and 'Verify that tests still pass' is mentioned but not given concrete commands or error recovery guidance. | 2 / 3 |
Progressive Disclosure | References to 'references/rules.md' are clearly signaled and one level deep, which is good. However, no bundle files were provided, so we can't verify the reference exists. The main SKILL.md itself is quite long (~180 lines) with content that could be split out (e.g., the detailed refactoring strategies, code counting rules, and automation config could live in reference files), making the overview heavier than ideal. | 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.
cb03f92
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.