Performs structured code reviews on Python and FastAPI codebases covering correctness, async safety, security, Pydantic v2 patterns, testing, and style.
62
72%
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/code-review-python/SKILL.mdQuality
Discovery
67%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 is strong in specificity and distinctiveness, clearly identifying the technology stack and review dimensions. However, it lacks an explicit 'Use when...' clause, which is critical for Claude to know when to select this skill. Trigger terms could also be improved to match more natural user language.
Suggestions
Add a 'Use when...' clause, e.g., 'Use when the user asks for a code review of Python or FastAPI code, or mentions reviewing async handlers, Pydantic models, or API endpoints.'
Include more natural trigger terms users would say, such as 'PR review', 'pull request', 'review my code', 'code quality check', or 'API review'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions/areas: correctness, async safety, security, Pydantic v2 patterns, testing, and style. Also specifies the technology stack (Python, FastAPI). | 3 / 3 |
Completeness | Clearly answers 'what does this do' (structured code reviews covering specific areas), but lacks an explicit 'Use when...' clause or equivalent trigger guidance, which caps this at 2 per the rubric. | 2 / 3 |
Trigger Term Quality | Includes good keywords like 'code reviews', 'Python', 'FastAPI', 'Pydantic v2', 'async safety', and 'security', but misses common user phrasings like 'review my code', 'PR review', 'pull request', or 'code quality'. Users might not say 'structured code reviews'. | 2 / 3 |
Distinctiveness Conflict Risk | Highly distinctive due to the specific technology stack (Python + FastAPI) and the enumerated review dimensions (async safety, Pydantic v2 patterns). Unlikely to conflict with generic code review or other language-specific review skills. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
77%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, well-structured code review skill with strong actionability and clear workflow sequencing. Its main weakness is verbosity — it explains general software engineering concepts (DRY, SRP, off-by-one errors) that Claude already knows, diluting the genuinely valuable domain-specific content like Pydantic v2 migration patterns and FastAPI best practices. Trimming the general knowledge sections and extracting detailed reference material into separate files would significantly improve token efficiency.
Suggestions
Remove or drastically shorten sections covering general knowledge Claude already has (Design & Architecture principles like SRP/DRY, basic exception handling concepts, what off-by-one errors are) and focus on the project-specific or non-obvious guidance.
Extract detailed reference content (Pydantic v2 migration patterns, FastAPI patterns, output format template) into separate bundle files and reference them from the main SKILL.md to improve progressive disclosure and reduce token cost.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is fairly well-organized but includes some content Claude already knows (e.g., explaining what off-by-one errors are, what DRY means, basic PEP 8 import ordering). Several sections like Design & Architecture and Documentation & Readability cover general software engineering principles that don't add novel knowledge. However, the Pydantic v2 migration specifics and FastAPI-specific patterns are genuinely useful additions. | 2 / 3 |
Actionability | The skill provides concrete, specific guidance throughout: exact Pydantic v2 method names to use vs. avoid, specific FastAPI patterns with named methods, a concrete example annotation style for bug reporting, a precise output format template with severity categories, and a copy-paste-ready checklist. The guidance is specific enough to be directly executable in a review context. | 3 / 3 |
Workflow Clarity | The review process is clearly sequenced from understanding intent (step 1) through correctness, security, patterns, design, testing, documentation, style, and finally output format (step 10). The output format section provides an explicit structured template with severity levels (Critical/Improvements/Nits/Positive), and the quick reference checklist serves as a validation checkpoint before finalizing. For a code review skill, this is a well-defined workflow. | 3 / 3 |
Progressive Disclosure | The content is well-structured with clear headers and logical sections, but it's a monolithic ~200-line document with no references to external files. Sections like Pydantic patterns, FastAPI patterns, and the output format template could be split into separate reference files to keep the main skill leaner. However, given no bundle files exist, everything must be inline, which partially justifies the approach. | 2 / 3 |
Total | 10 / 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.
c0b2e4b
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.