Review Multi

Review-Multi

Overview

review-multi provides a systematic framework for conducting comprehensive, multi-dimensional reviews of Claude Code skills. It evaluates skills across 5 independent dimensions, combining automated validation with manual assessment to deliver objective quality scores and actionable improvement recommendations.

Purpose: Systematic skill quality assurance through multi-dimensional assessment

The 5 Review Dimensions:

1. Structure Review - YAML frontmatter, file organization, naming conventions, progressive disclosure
2. Content Review - Section completeness, clarity, examples, documentation quality
3. Quality Review - Pattern compliance, best practices, anti-pattern detection, code quality
4. Usability Review - Ease of use, learnability, real-world effectiveness, user satisfaction
5. Integration Review - Dependency documentation, data flow, component integration, composition

Automation Levels:

• Structure: 95% automated (validate-structure.py)
• Content: 40% automated, 60% manual assessment
• Quality: 50% automated, 50% manual assessment
• Usability: 10% automated, 90% manual testing
• Integration: 30% automated, 70% manual review

Scoring System:

• Scale: 1-5 per dimension (Excellent/Good/Acceptable/Needs Work/Poor)
• Overall Score: Weighted average across dimensions
• Grade: A/B/C/D/F mapping
• Production Readiness: ≥4.5 ready, 4.0-4.4 ready with improvements, 3.5-3.9 needs work, <3.5 not ready

Value Proposition:

• Objective: Evidence-based scoring using detailed rubrics (not subjective opinion)
• Comprehensive: 5 dimensions cover all quality aspects
• Efficient: Automation handles 30-95% of checks depending on dimension
• Actionable: Specific, prioritized improvement recommendations
• Consistent: Standardized checklists ensure repeatable results
• Flexible: 3 review modes (Comprehensive, Fast Check, Custom)

Key Benefits:

• Catch 70% of issues with fast automated checks
• Reduce common quality issues by 30% using checklists
• Ensure production readiness before deployment
• Identify improvement opportunities systematically
• Track quality improvements over time
• Establish quality standards across skill ecosystem

When to Use

Use review-multi when:

1. Pre-Production Validation - Review new skills before deploying to production to catch issues early and ensure quality standards

2. Quality Assurance - Conduct systematic QA on skills to validate they meet ecosystem standards and user needs

3. Identifying Improvements - Discover specific, actionable improvements for existing skills through multi-dimensional assessment

4. Continuous Improvement - Regular reviews throughout development lifecycle, not just at end, to maintain quality

5. Production Readiness Assessment - Determine if skill is ready for production use with objective scoring and grade mapping

6. Skill Ecosystem Standards - Ensure consistency and quality across multiple skills using standardized review framework

7. Post-Update Validation - Review skills after major updates to ensure changes don't introduce issues or degrade quality

8. Learning and Improvement - Use review findings to learn patterns, improve future skills, and refine development practices

9. Team Calibration - Standardize quality assessment across multiple reviewers with objective rubrics

Don't Use When:

• Quick syntax checks (use validate-structure.py directly)
• In-progress drafts (wait until reasonably complete)
• Experimental prototypes (not production-bound)

Prerequisites

Required:

• Skill to review (in .claude/skills/[skill-name]/ format)
• Time allocation based on review mode:
  • Fast Check: 5-10 minutes
  • Single Operation: 15-60 minutes (varies by dimension)
  • Comprehensive Review: 1.5-2.5 hours

Optional:

• Python 3.7+ (for automation scripts in Structure and Quality reviews)
• PyYAML library (for YAML frontmatter validation)
• Access to skill-under-review documentation
• Familiarity with Claude Code skill patterns (see development-workflow/references/common-patterns.md)

Skills (no required dependencies, complementary):

• development-workflow: Use review-multi after skill development
• skill-updater: Apply review-multi recommendations
• testing-validator: Combine with review-multi for full QA

Scoring System

The review-multi scoring system provides objective, consistent quality assessment across all skill dimensions.

Per-Dimension Scoring (1-5 Scale)

Each dimension is scored independently using a 1-5 integer scale:

5 - Excellent (Exceeds Standards)

• All criteria met perfectly
• Goes beyond minimum requirements
• Exemplary quality that sets the bar
• No issues or concerns identified
• Can serve as example for others

4 - Good (Meets Standards)

• Meets all critical criteria
• 1-2 minor, non-critical issues
• Production-ready quality
• Standard expected level
• Small improvements possible

3 - Acceptable (Minor Improvements Needed)

• Meets most criteria
• 3-4 issues, some may be critical
• Usable but not optimal
• Several improvements recommended
• Can proceed with noted concerns

2 - Needs Work (Notable Issues)

• Missing several criteria
• 5-6 issues, multiple critical
• Not production-ready
• Significant improvements required
• Rework needed before deployment

1 - Poor (Significant Problems)

• Fails most criteria
• 7+ issues, fundamentally flawed
• Major quality concerns
• Extensive rework required
• Not viable in current state

Overall Score Calculation

The overall score is a weighted average of the 5 dimension scores:

Overall = (Structure × 0.20) + (Content × 0.25) + (Quality × 0.25) +
          (Usability × 0.15) + (Integration × 0.15)

Weight Rationale:

• Content & Quality (25% each): Core skill value - what it does and how well
• Structure (20%): Important foundation - organization and compliance
• Usability & Integration (15% each): Supporting factors - user experience and composition

Example Calculations:

• Scores (5, 4, 4, 3, 4) → Overall = (5×0.20 + 4×0.25 + 4×0.25 + 3×0.15 + 4×0.15) = 4.15 → Grade B
• Scores (4, 5, 5, 4, 4) → Overall = (4×0.20 + 5×0.25 + 5×0.25 + 4×0.15 + 4×0.15) = 4.55 → Grade A
• Scores (3, 3, 2, 3, 3) → Overall = (3×0.20 + 3×0.25 + 2×0.25 + 3×0.15 + 3×0.15) = 2.85 → Grade C

Grade Mapping

Overall scores map to letter grades:

• A (4.5-5.0): Excellent - Production ready, high quality
• B (3.5-4.4): Good - Ready with minor improvements
• C (2.5-3.4): Acceptable - Needs improvements before production
• D (1.5-2.4): Poor - Requires significant rework
• F (1.0-1.4): Failing - Major issues, not viable

Production Readiness Assessment

Based on overall score:

• ≥4.5 (Grade A): ✅ Production Ready - High quality, deploy with confidence
• 4.0-4.4 (Grade B+): ✅ Ready with Minor Improvements - Can deploy, address improvements in next iteration
• 3.5-3.9 (Grade B-): ⚠️ Needs Improvements - Address issues before production deployment
• <3.5 (Grade C-F): ❌ Not Ready - Significant rework required before deployment

Decision Framework:

• A Grade: Ship it - exemplary quality
• B Grade (4.0+): Ship it - standard quality, note improvements for future
• B- Grade (3.5-3.9): Hold - fix identified issues first
• C-F Grade: Don't ship - substantial work needed

Operations

Operation 1: Structure Review

Purpose: Validate file organization, naming conventions, YAML frontmatter compliance, and progressive disclosure

When to Use This Operation:

• Always run first (fast automated check catches 70% of issues)
• Before comprehensive review (quick validation of basics)
• During development (continuous structure validation)
• Quick quality checks (5-10 minute validation)

Automation Level: 95% automated via scripts/validate-structure.py

Process:

1. Run Structure Validation Script

   python3 scripts/validate-structure.py /path/to/skill [--json] [--verbose]
   

   Script checks YAML, file structure, naming, progressive disclosure

2. Review YAML Frontmatter

   • Verify name field in kebab-case format
   • Check description has 5+ trigger keywords naturally embedded
   • Validate YAML syntax is correct

3. Verify File Structure

   • Confirm SKILL.md exists
   • Check references/ and scripts/ organization (if present)
   • Verify README.md exists

4. Check Naming Conventions

   • SKILL.md and README.md uppercase
   • references/ files: lowercase-hyphen-case
   • scripts/ files: lowercase-hyphen-case with extension

5. Validate Progressive Disclosure

   • SKILL.md <1,500 lines (warn if >1,200)
   • references/ files 300-800 lines each
   • No monolithic files

Validation Checklist:

• YAML frontmatter present and valid syntax
• name field in kebab-case format (e.g., skill-name)
• description includes 5+ trigger keywords (naturally embedded)
• SKILL.md file exists
• File naming follows conventions (SKILL.md uppercase, references lowercase-hyphen)
• Directory structure correct (references/, scripts/ if present)
• SKILL.md size appropriate (<1,500 lines, ideally <1,200)
• References organized by topic (if present)
• No monolithic files (progressive disclosure maintained)
• README.md present

Scoring Criteria:

• 5 - Excellent: All 10 checks pass, perfect compliance, exemplary structure
• 4 - Good: 8-9 checks pass, 1-2 minor non-critical issues (e.g., README missing but optional)
• 3 - Acceptable: 6-7 checks pass, 3-4 issues including some critical (e.g., YAML invalid but fixable)
• 2 - Needs Work: 4-5 checks pass, 5-6 issues with multiple critical (e.g., no SKILL.md, bad naming)
• 1 - Poor: ≤3 checks pass, 7+ issues, fundamentally flawed structure

Outputs:

• Structure score (1-5)
• Pass/fail status for each checklist item
• List of issues found with severity (critical/warning/info)
• Specific improvement recommendations with fix guidance
• JSON report (if using script with --json flag)

Time Estimate: 5-10 minutes (mostly automated)

Example:

$ python3 scripts/validate-structure.py .claude/skills/todo-management

Structure Validation Report
===========================
Skill: todo-management
Date: 2025-11-06

✅ YAML Frontmatter: PASS
   - Name format: valid (kebab-case)
   - Trigger keywords: 8 found (target: 5+)

✅ File Structure: PASS
   - SKILL.md: exists
   - README.md: exists
   - references/: 3 files found
   - scripts/: 1 file found

✅ Naming Conventions: PASS
   - All files follow conventions

⚠️  Progressive Disclosure: WARNING
   - SKILL.md: 569 lines (good)
   - state-management-guide.md: 501 lines (good)
   - BUT: No Quick Reference section detected

Overall Structure Score: 4/5 (Good)
Issues: 1 warning (missing Quick Reference)
Recommendation: Add Quick Reference section to SKILL.md

Operation 2: Content Review

Purpose: Assess section completeness, content clarity, example quality, and documentation comprehensiveness

When to Use This Operation:

• Evaluate documentation quality
• Assess completeness of skill content
• Review example quality and quantity
• Validate information architecture
• Check clarity and organization

Automation Level: 40% automated (section detection, example counting), 60% manual assessment

Process:

1. Check Section Completeness (automated + manual)

   • Verify 5 core sections present: Overview, When to Use, Main Content (workflow/operations), Best Practices, Quick Reference
   • Check optional sections: Prerequisites, Common Mistakes, Troubleshooting
   • Assess if all necessary sections included

2. Assess Content Clarity (manual)

   • Is content understandable?
   • Is organization logical?
   • Are explanations clear without being verbose?
   • Is technical level appropriate for audience?

3. Evaluate Example Quality (automated count + manual quality)

   • Count code/command examples (target: 5+)
   • Check if examples are concrete (not abstract placeholders)
   • Verify examples are executable/copy-pasteable
   • Assess if examples help understanding

4. Review Documentation Completeness (manual)

   • Is all necessary information present?
   • Are there unexplained gaps?
   • Is sufficient detail provided?
   • Are edge cases covered?

5. Check Explanation Depth (manual)

   • Not too brief (insufficient detail)?
   • Not too verbose (unnecessary length)?
   • Balanced depth for complexity?

Validation Checklist:

• Overview/Introduction section present
• When to Use section present with 5+ scenarios
• Main content (workflow steps OR operations OR reference material) complete
• Best Practices section present
• Quick Reference section present
• 5+ code/command examples included
• Examples are concrete (not abstract placeholders like "YOUR_VALUE_HERE")
• Content clarity: readable and well-structured
• Sufficient detail: not too brief
• Not too verbose: concise without unnecessary length

Scoring Criteria:

• 5 - Excellent: All 10 checks pass, exceptional clarity, great examples, comprehensive documentation
• 4 - Good: 8-9 checks pass, good content with minor gaps or clarity issues
• 3 - Acceptable: 6-7 checks pass, some sections weak or missing, acceptable clarity
• 2 - Needs Work: 4-5 checks pass, multiple sections incomplete/unclear, poor examples
• 1 - Poor: ≤3 checks pass, major gaps, confusing content, few/no examples

Outputs:

• Content score (1-5)
• Section-by-section assessment (present/missing/weak)
• Example quality rating and count
• Specific content improvement recommendations
• Clarity issues identified with examples

Time Estimate: 15-30 minutes (requires manual review)

Example:

Content Review: prompt-builder
==============================

Section Completeness: 9/10 ✅
✅ Overview: Present, clear explanation of purpose
✅ When to Use: 7 scenarios listed
✅ Main Content: 5-step workflow, well-organized
✅ Best Practices: 6 practices documented
✅ Quick Reference: Present
⚠️  Common Mistakes: Not present (optional but valuable)

Example Quality: 8/10 ✅
- Count: 12 examples (exceeds target of 5+)
- Concrete: Yes, all examples executable
- Helpful: Yes, demonstrate key concepts
- Minor: Could use 1-2 edge case examples

Content Clarity: 9/10 ✅
- Well-organized logical flow
- Clear explanations without verbosity
- Technical level appropriate
- Minor: Step 3 could be clearer (add diagram)

Documentation Completeness: 8/10 ✅
- All workflow steps documented
- Validation criteria clear
- Minor gaps: Error handling not covered

Content Score: 4/5 (Good)
Primary Recommendation: Add Common Mistakes section
Secondary: Add error handling guidance to Step 3

Operation 3: Quality Review

Purpose: Evaluate pattern compliance, best practices adherence, anti-pattern detection, and code/script quality

When to Use This Operation:

• Validate standards compliance
• Check pattern implementation
• Detect anti-patterns
• Assess code quality (if scripts present)
• Ensure best practices followed

Automation Level: 50% automated (pattern detection, anti-pattern checking), 50% manual assessment

Process:

1. Detect Architecture Pattern (automated + manual)

   • Identify pattern type: workflow/task/reference/capabilities
   • Verify pattern correctly implemented
   • Check pattern consistency throughout skill

2. Validate Documentation Patterns (automated + manual)

   • Verify 5 core sections present
   • Check consistent structure across steps/operations
   • Validate section formatting

3. Check Best Practices (manual)

   • Validation checklists present and specific?
   • Examples throughout documentation?
   • Quick Reference available?
   • Error cases considered?

4. Detect Anti-Patterns (automated + manual)

   • Keyword stuffing (trigger keywords unnatural)?
   • Monolithic SKILL.md (>1,500 lines, no progressive disclosure)?
   • Inconsistent structure (each section different format)?
   • Vague validation ("everything works")?
   • Missing examples (too abstract)?
   • Placeholders in production ("YOUR_VALUE_HERE")?
   • Ignoring error cases (only happy path)?
   • Over-engineering simple skills?
   • Unclear dependencies?
   • No Quick Reference?

5. Assess Code Quality (manual, if scripts present)

   • Scripts well-documented (docstrings)?
   • Error handling present?
   • CLI interfaces clear?
   • Code style consistent?

Validation Checklist:

• Architecture pattern correctly implemented (workflow/task/reference/capabilities)
• Consistent structure across steps/operations (same format throughout)
• Validation checklists present and specific (measurable, not vague)
• Best practices section actionable (specific guidance)
• No keyword stuffing (trigger keywords natural, contextual)
• No monolithic SKILL.md (progressive disclosure used if >1,000 lines)
• Examples are complete (no "YOUR_VALUE_HERE" placeholders in production)
• Error cases considered (not just happy path documented)
• Dependencies documented (if skill requires other skills)
• Scripts well-documented (if present: docstrings, error handling, CLI help)

Scoring Criteria:

• 5 - Excellent: All 10 checks pass, exemplary quality, no anti-patterns, exceeds standards
• 4 - Good: 8-9 checks pass, high quality, meets all standards, minor deviations
• 3 - Acceptable: 6-7 checks pass, acceptable quality, some standard violations, 2-3 anti-patterns
• 2 - Needs Work: 4-5 checks pass, quality issues, multiple standard violations, 4-5 anti-patterns
• 1 - Poor: ≤3 checks pass, poor quality, significant problems, 6+ anti-patterns detected

Outputs:

• Quality score (1-5)
• Pattern compliance assessment (pattern detected, compliance level)
• Anti-patterns detected (list with severity)
• Best practices gaps identified
• Code quality assessment (if scripts present)
• Prioritized improvement recommendations

Time Estimate: 20-40 minutes (mixed automated + manual)

Example:

Quality Review: workflow-skill-creator
======================================

Pattern Compliance: ✅
- Pattern Detected: Workflow-based
- Implementation: Correct (5 sequential steps with dependencies)
- Consistency: High (all steps follow same structure)

Documentation Patterns: ✅
- 5 Core Sections: All present
- Structure: Consistent across all 5 steps
- Formatting: Proper heading levels

Best Practices Adherence: 8/10 ✅
✅ Validation checklists: Present and specific
✅ Examples throughout: 6 examples included
✅ Quick Reference: Present
⚠️ Error handling: Limited (only happy path in examples)

Anti-Pattern Detection: 1 detected ⚠️
✅ No keyword stuffing (15 natural keywords)
✅ No monolithic file (1,465 lines but has references/)
✅ Consistent structure
✅ Specific validation criteria
✅ Examples complete (no placeholders)
⚠️ Error cases: Only happy path documented
✅ Dependencies: Clearly documented
✅ Not over-engineered

Code Quality: N/A (no scripts)

Quality Score: 4/5 (Good)
Primary Issue: Limited error handling documentation
Recommendation: Add error case examples and recovery guidance

Operation 4: Usability Review

Purpose: Evaluate ease of use, learnability, real-world effectiveness, and user satisfaction through scenario testing

When to Use This Operation:

• Test real-world usage
• Assess user experience
• Evaluate learnability
• Measure effectiveness
• Validate skill achieves stated purpose

Automation Level: 10% automated (basic checks), 90% manual testing

Process:

1. Test in Real-World Scenario

   • Select appropriate use case from "When to Use" section
   • Actually use the skill to complete task
   • Document experience: smooth or friction?
   • Note any confusion or difficulty

2. Assess Navigation/Findability

   • Can you find needed information easily?
   • Is information architecture logical?
   • Are sections well-organized?
   • Is Quick Reference helpful?

3. Evaluate Clarity

   • Are instructions clear and actionable?
   • Are steps easy to follow?
   • Do examples help understanding?
   • Is technical terminology explained?

4. Measure Effectiveness

   • Does skill achieve stated purpose?
   • Does it deliver promised value?
   • Are outputs useful and complete?
   • Would you use it again?

5. Assess Learning Curve

   • How long to understand skill?
   • How long to use effectively?
   • Is learning curve reasonable for complexity?
   • Are first-time users supported well?

Validation Checklist:

• Skill tested in real-world scenario (actual usage, not just reading)
• Users can find information easily (navigation clear, sections logical)
• Instructions are clear and actionable (can follow without confusion)
• Examples help understanding (concrete, demonstrate key concepts)
• Skill achieves stated purpose (delivers promised value)
• Learning curve reasonable (appropriate for skill complexity)
• Error messages helpful (if applicable: clear, actionable guidance)
• Overall user satisfaction high (would use again, recommend to others)

Scoring Criteria:

• 5 - Excellent: All 8 checks pass, excellent usability, easy to learn, highly effective, very satisfying
• 4 - Good: 6-7 checks pass, good usability, minor friction points, generally effective
• 3 - Acceptable: 4-5 checks pass, acceptable usability, some confusion/difficulty, moderately effective
• 2 - Needs Work: 2-3 checks pass, usability issues, frustrating or confusing, limited effectiveness
• 1 - Poor: ≤1 check passes, poor usability, hard to use, ineffective, unsatisfying

Outputs:

• Usability score (1-5)
• Scenario test results (success/partial/failure)
• User experience assessment (smooth/acceptable/frustrating)
• Specific usability improvements identified
• Learning curve assessment
• Effectiveness rating

Time Estimate: 30-60 minutes (requires actual testing)

Example:

Usability Review: skill-researcher
==================================

Real-World Scenario Test: ✅
- Scenario: Research GitHub API integration patterns
- Result: SUCCESS - Found 5 relevant sources, synthesized findings
- Experience: Smooth, operations clearly explained
- Time: 45 minutes (expected 60 min range)

Navigation/Findability: 9/10 ✅
- Information easy to find
- 5 operations clearly separated
- Quick Reference table very helpful
- Minor: Could use table of contents for long doc

Instruction Clarity: 9/10 ✅
- Steps clear and actionable
- Process well-explained
- Examples demonstrate concepts
- Minor: Web search query formulation could be clearer

Effectiveness: 10/10 ✅
- Achieved purpose: Found patterns and synthesized
- Delivered value: Comprehensive research in 45 min
- Would use again: Yes, very helpful

Learning Curve: 8/10 ✅
- Time to understand: 10 minutes
- Time to use effectively: 15 minutes
- Reasonable for complexity
- First-time user: Some concepts need explanation (credibility scoring)

Error Handling: N/A (no errors encountered)

User Satisfaction: 9/10 ✅
- Would use again: Yes
- Would recommend: Yes
- Overall experience: Very positive

Usability Score: 5/5 (Excellent)
Minor Improvement: Add brief explanation of credibility scoring concept

Operation 5: Integration Review

Purpose: Assess dependency documentation, data flow clarity, component integration, and composition patterns

When to Use This Operation:

• Review workflow skills (that compose other skills)
• Validate dependency documentation
• Check integration clarity
• Assess composition patterns
• Verify cross-references valid

Automation Level: 30% automated (dependency checking, cross-reference validation), 70% manual assessment

Process:

1. Review Dependency Documentation (manual)

   • Are required skills documented?
   • Are optional/complementary skills mentioned?
   • Is YAML dependencies field used (if applicable)?
   • Are dependency versions noted (if relevant)?

2. Assess Data Flow Clarity (manual, for workflow skills)

   • Is data flow between skills explained?
   • Are inputs/outputs documented for each step?
   • Do users understand how data moves?
   • Are there diagrams or flowcharts (if helpful)?

3. Evaluate Component Integration (manual)

   • How do component skills work together?
   • Are integration points clear?
   • Are there integration examples?
   • Is composition pattern documented?

4. Verify Cross-References (automated + manual)

   • Do internal links work (references to references/, scripts/)?
   • Are external skill references correct?
   • Are complementary skills mentioned?

5. Check Composition Patterns (manual, for workflow skills)

   • Is composition pattern identified (sequential/parallel/conditional/etc.)?
   • Is pattern correctly implemented?
   • Are orchestration details provided?

Validation Checklist:

• Dependencies documented (if skill requires other skills)
• YAML dependencies field correct (if used)
• Data flow explained (for workflow skills: inputs/outputs clear)
• Integration points clear (how component skills connect)
• Component skills referenced correctly (names accurate, paths valid)
• Cross-references valid (internal links work, external references correct)
• Integration examples provided (if applicable: how to use together)
• Composition pattern documented (if workflow: sequential/parallel/etc.)
• Complementary skills mentioned (optional but valuable related skills)

Scoring Criteria:

• 5 - Excellent: All 9 checks pass (applicable ones), perfect integration documentation
• 4 - Good: 7-8 checks pass, good integration, minor gaps in documentation
• 3 - Acceptable: 5-6 checks pass, some integration unclear, missing details
• 2 - Needs Work: 3-4 checks pass, integration issues, poorly documented dependencies/flow
• 1 - Poor: ≤2 checks pass, poor integration, confusing or missing dependency documentation

Outputs:

• Integration score (1-5)
• Dependency validation results (required/optional/complementary documented)
• Data flow clarity assessment (for workflow skills)
• Integration clarity rating
• Cross-reference validation results
• Improvement recommendations

Time Estimate: 15-25 minutes (mostly manual)

Example:

Integration Review: development-workflow
========================================

Dependency Documentation: 10/10 ✅
- Required Skills: None (workflow is standalone)
- Component Skills: 5 clearly documented (skill-researcher, planning-architect, task-development, prompt-builder, todo-management)
- Optional Skills: 3 complementary skills mentioned (review-multi, skill-updater, testing-validator)
- YAML Field: Not used (not required, skills referenced in content)

Data Flow Clarity: 10/10 ✅ (Workflow Skill)
- Data flow diagram present (skill → output → next skill)
- Inputs/outputs for each step documented
- Users understand how artifacts flow
- Example:

skill-researcher → research-synthesis.md → planning-architect ↓ skill-architecture-plan.md → task-development

Component Integration: 10/10 ✅
- Integration method documented for each step (Guided Execution)
- Integration examples provided
- Clear explanation of how skills work together
- Process for using each component skill detailed

Cross-Reference Validation: ✅
- Internal links valid (references/ files exist and reachable)
- External skill references correct (all 5 component skills exist)
- Complementary skills mentioned appropriately

Composition Pattern: 10/10 ✅ (Workflow Skill)
- Pattern: Sequential Pipeline (with one optional step)
- Correctly implemented (Step 1 → 2 → [3 optional] → 4 → 5)
- Orchestration details provided
- Clear flow diagram

Integration Score: 5/5 (Excellent)
Notes: Exemplary integration documentation for workflow skill

Review Modes

Comprehensive Review Mode

Purpose: Complete multi-dimensional assessment across all 5 dimensions with aggregate scoring

When to Use:

• Pre-production validation (ensure skill ready for deployment)
• Major skill updates (validate changes don't degrade quality)
• Quality certification (establish baseline quality score)
• Periodic quality audits (track quality over time)

Process:

1. Run All 5 Operations Sequentially

   • Operation 1: Structure Review (5-10 min, automated)
   • Operation 2: Content Review (15-30 min, manual)
   • Operation 3: Quality Review (20-40 min, mixed)
   • Operation 4: Usability Review (30-60 min, manual)
   • Operation 5: Integration Review (15-25 min, manual)

2. Aggregate Scores

   • Record score (1-5) for each dimension
   • Calculate weighted overall score using formula
   • Map overall score to grade (A/B/C/D/F)

3. Assess Production Readiness

   • ≥4.5: Production Ready
   • 4.0-4.4: Ready with minor improvements
   • 3.5-3.9: Needs improvements before production
   • <3.5: Not ready, significant rework required

4. Compile Improvement Recommendations

   • Aggregate issues from all dimensions
   • Prioritize: Critical → High → Medium → Low
   • Provide specific, actionable fixes

5. Generate Comprehensive Report

   • Executive summary (overall score, grade, readiness)
   • Per-dimension scores and findings
   • Prioritized improvement list
   • Detailed rationale for scores

Output:

• Overall score (1.0-5.0 with one decimal)
• Grade (A/B/C/D/F)
• Production readiness assessment
• Per-dimension scores (Structure, Content, Quality, Usability, Integration)
• Comprehensive improvement recommendations (prioritized)
• Detailed review report

Time Estimate: 1.5-2.5 hours total

Example Output:

Comprehensive Review Report: skill-researcher
=============================================

OVERALL SCORE: 4.6/5.0 - GRADE A
STATUS: ✅ PRODUCTION READY

Dimension Scores:
- Structure:   5/5 (Excellent) - Perfect file organization
- Content:     5/5 (Excellent) - Comprehensive, clear documentation
- Quality:     4/5 (Good) - High quality, minor error handling gaps
- Usability:   5/5 (Excellent) - Easy to use, highly effective
- Integration: 4/5 (Good) - Well-documented dependencies

Production Readiness: READY - High quality, deploy with confidence

Recommendations (Priority Order):
1. [Medium] Add error handling examples for web search failures
2. [Low] Consider adding table of contents for long SKILL.md

Strengths:
- Excellent structure and organization
- Comprehensive coverage of 5 research operations
- Strong usability with clear instructions
- Good examples throughout

Overall: Exemplary skill, production-ready quality

Fast Check Mode

Purpose: Quick automated validation for rapid quality feedback during development

When to Use:

• During development (continuous validation)
• Quick quality checks (before detailed review)
• Pre-commit validation (catch issues early)
• Rapid iteration (fast feedback loop)

Process:

1. Run Automated Structure Validation

   python3 scripts/validate-structure.py /path/to/skill
   

2. Check Critical Issues

   • YAML frontmatter valid?
   • Required files present?
   • Naming conventions followed?
   • File sizes appropriate?

3. Generate Pass/Fail Report

   • PASS: Critical checks passed, proceed to development
   • FAIL: Critical issues found, fix before continuing

4. Provide Quick Fixes (if available)

   • Specific commands to fix issues
   • Examples of correct format
   • References to documentation

Output:

• Pass/Fail status
• Critical issues list (if failed)
• Quick fixes or guidance
• Score estimate (if passed)

Time Estimate: 5-10 minutes

Example Output:

$ python3 scripts/validate-structure.py .claude/skills/my-skill

Fast Check Report
=================
Skill: my-skill

❌ FAIL - Critical Issues Found

Critical Issues:
1. YAML frontmatter: Invalid syntax (line 3: unexpected character)
2. Naming convention: File "MyGuide.md" should be "my-guide.md"

Quick Fixes:
1. Fix YAML: Remove trailing comma on line 3
2. Rename file: mv references/MyGuide.md references/my-guide.md

Run full validation after fixes: python3 scripts/validate-structure.py .claude/skills/my-skill

Custom Review

Purpose: Flexible review focusing on specific dimensions or concerns

When to Use:

• Targeted improvements (focus on specific dimension)
• Time constraints (can't do comprehensive review)
• Specific concerns (e.g., only check usability)
• Iterative improvements (focus on one dimension at a time)

Options:

1. Select Dimensions: Choose 1-5 operations to run
2. Adjust Thoroughness: Quick/Standard/Thorough per dimension
3. Focus Areas: Specify particular concerns (e.g., "check examples quality")

Process:

1. Define Custom Review Scope

   • Which dimensions to review?
   • How thorough for each?
   • Any specific focus areas?

2. Run Selected Operations

   • Execute chosen operations
   • Apply thoroughness level

3. Generate Targeted Report

   • Scores for selected dimensions only
   • Focused findings
   • Specific recommendations

Example Scenarios:

Scenario 1: Content-Focused Review

Custom Review: Content + Examples
- Operations: Content Review only
- Thoroughness: Thorough
- Focus: Example quality and completeness
- Time: 30 minutes

Scenario 2: Quick Quality Check

Custom Review: Structure + Quality (Fast)
- Operations: Structure + Quality
- Thoroughness: Quick
- Focus: Pattern compliance, anti-patterns
- Time: 15-20 minutes

Scenario 3: Workflow Integration Review

Custom Review: Integration Deep Dive
- Operations: Integration Review only
- Thoroughness: Thorough
- Focus: Data flow, composition patterns
- Time: 30 minutes

Best Practices

1. Self-Review First

Practice: Run Fast Check mode before requesting comprehensive review

Rationale: Automated checks catch 70% of structural issues in 5-10 minutes, allowing manual review to focus on higher-value assessment

Application: Always run validate-structure.py before detailed review

2. Use Checklists Systematically

Practice: Follow validation checklists item-by-item for each operation

Rationale: Research shows teams using checklists reduce common issues by 30% and ensure consistent results

Application: Print or display checklist, mark each item explicitly

3. Test in Real Scenarios

Practice: Conduct usability review with actual usage, not just documentation reading

Rationale: Real-world testing reveals hidden usability issues that documentation review misses

Application: For Usability Review, actually use the skill to complete a realistic task

4. Focus on Automation

Practice: Let scripts handle routine checks, focus manual effort on judgment-requiring assessment

Rationale: Automation provides 70% reduction in manual review time for routine checks

Application: Use scripts for Structure and partial Quality checks, manual for Content/Usability

5. Provide Actionable Feedback

Practice: Make improvement recommendations specific, prioritized, and actionable

Rationale: Vague feedback ("improve quality") is less valuable than specific guidance ("add error handling examples to Step 3")

Application: For each issue, specify: What, Why, How (to fix), Priority

6. Review Regularly

Practice: Conduct reviews throughout development lifecycle, not just at end

Rationale: Early reviews catch issues before they compound; rapid feedback maintains momentum (37% productivity increase)

Application: Fast Check during development, Comprehensive Review before production

7. Track Improvements

Practice: Document before/after scores to measure improvement over time

Rationale: Tracking demonstrates progress, identifies patterns, validates improvements

Application: Save review reports, compare scores across iterations

8. Iterate Based on Findings

Practice: Use review findings to improve future skills, not just current skill

Rationale: Learnings compound; patterns identified in reviews improve entire skill ecosystem

Application: Document common issues, create guidelines, update templates

Common Mistakes

Mistake 1: Skipping Structure Review

Symptom: Spending time on detailed review only to discover fundamental structural issues

Cause: Assumption that structure is correct, eagerness to assess content

Fix: Always run Structure Review (Fast Check) first - takes 5-10 minutes, catches 70% of issues

Prevention: Make Fast Check mandatory first step in any review process

Mistake 2: Subjective Scoring

Symptom: Inconsistent scores, debate over ratings, difficulty justifying scores

Cause: Using personal opinion instead of rubric criteria

Fix: Use references/scoring-rubric.md - score based on specific criteria, not feeling

Prevention: Print rubric, refer to criteria for each score, document evidence

Mistake 3: Ignoring Usability

Symptom: Skill looks good on paper but difficult to use in practice

Cause: Skipping Usability Review (90% manual, time-consuming)

Fix: Actually test skill in real scenario - reveals hidden issues

Prevention: Allocate 30-60 minutes for usability testing, cannot skip for production

Mistake 4: No Prioritization

Symptom: Long list of improvements, unclear what to fix first, overwhelmed

Cause: Treating all issues equally without assessing impact

Fix: Prioritize issues: Critical (must fix) → High → Medium → Low (nice to have)

Prevention: Tag each issue with priority level during review

Mistake 5: Batch Reviews

Symptom: Discovering major issues late in development, costly rework

Cause: Waiting until end to review, accumulating issues

Fix: Review early and often - Fast Check during development, iterations

Prevention: Continuous validation, rapid feedback, catch issues when small

Mistake 6: Ignoring Patterns

Symptom: Repeating same issues across multiple skills

Cause: Treating each review in isolation, not learning from patterns

Fix: Track common issues, create guidelines, update development process

Prevention: Document patterns, share learnings, improve templates

Quick Reference

The 5 Operations

Scoring Scale

Production Readiness

…(truncated)