structured-code-review
Performs a structured five-stage code review covering requirements compliance, correctness, code quality, testing, and security/performance. Each stage uses targeted checklists and categorized feedback (Blocker/Major/Minor/Nit) with actionable suggestions and rationale. Use when the user asks for code review, PR feedback, pull request review, or wants their code checked for bugs, style issues, or vulnerabilities — triggered by phrases like "review my code", "check this PR", "review my changes", "pull request review", or "code feedback".
84
81%
Does it follow best practices?
Impact
Pending
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 an excellent skill description that clearly articulates what the skill does (structured five-stage code review with categorized feedback), when to use it (explicit trigger phrases for code review scenarios), and how it differentiates itself (specific methodology with Blocker/Major/Minor/Nit categorization). It uses proper third-person voice throughout and provides comprehensive trigger term coverage.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: five-stage review covering requirements compliance, correctness, code quality, testing, and security/performance, with categorized feedback levels (Blocker/Major/Minor/Nit) and actionable suggestions with rationale. | 3 / 3 |
Completeness | Clearly answers both 'what' (structured five-stage code review with checklists and categorized feedback) and 'when' (explicit 'Use when...' clause with multiple trigger phrases and scenarios). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms users would say: 'code review', 'PR feedback', 'pull request review', 'review my code', 'check this PR', 'review my changes', 'code feedback', 'bugs', 'style issues', 'vulnerabilities'. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with its specific five-stage structured review methodology and severity categorization system. The focus on code review/PR feedback is a clear niche unlikely to conflict with general coding or document skills. | 3 / 3 |
Total | 12 / 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.
This is a well-structured instructional skill with a clear five-stage review methodology and useful feedback categorization. Its main weaknesses are moderate verbosity (redundant checklists, over-explained concepts like feedback levels that Claude already understands) and lack of a concrete end-to-end example showing the skill applied to actual code. The workflow sequencing is the strongest aspect.
Suggestions
Remove the summary checklist at the end since it duplicates the per-stage checklists, or keep only the summary and remove per-stage checklists to reduce redundancy.
Add a brief concrete example showing the complete output of a review applied to a small code snippet, demonstrating all five stages in action rather than just describing them.
Trim explanatory framing text like 'A structured review catches more issues...' and stage transition phrases ('First...', 'Next...', 'Then...', 'Finally...') — Claude doesn't need motivational context for following instructions.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is moderately verbose. The checklists and example feedback phrases are useful, but there's redundancy between the per-stage checklists and the summary checklist at the end. The 'Core Principle' section and some framing text ('First, verify...', 'Next, verify...', 'Then, evaluate...') add little value for Claude. The feedback template explanation is somewhat over-explained. | 2 / 3 |
Actionability | The skill provides concrete example feedback phrases and a structured template, which is helpful. However, it lacks executable code or specific commands — it's entirely instructional with example text snippets rather than demonstrating how to actually perform a review on real code. The checklist items are useful but somewhat generic and could be more specific. | 2 / 3 |
Workflow Clarity | The five-stage sequential workflow is clearly defined with explicit ordering and distinct focus areas. Each stage has a specific checklist and example outputs. The final summary checklist with a verdict step provides a clear completion checkpoint. For a review process (which is analytical rather than destructive), this level of workflow clarity is appropriate. | 3 / 3 |
Progressive Disclosure | The content is mostly monolithic — all five stages with full checklists, examples, and the feedback template are inline in a single file. The cross-references to other skills at the bottom are a nice touch, but the detailed feedback template and full summary checklist could potentially be separated. For a skill of this length (~120 lines of content), some splitting would improve scannability. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
- Repository
- rohitg00/skillkit
- Commit
dfa8d12
- 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.