fastapi-templates
Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.
71
56%
Does it follow best practices?
Impact
100%
1.21xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./tests/ext_conformance/artifacts/agents-wshobson/api-scaffolding/skills/fastapi-templates/SKILL.mdQuality
Discovery
75%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 solid description that clearly identifies its niche (FastAPI project creation) and includes an explicit 'Use when' clause. Its main weaknesses are that the capabilities listed are somewhat abstract (patterns and qualities rather than concrete actions) and the trigger terms could be broader to capture more natural user phrasings like 'REST API' or 'Python web server'.
Suggestions
Add more concrete actions like 'scaffold routes, configure middleware, set up Pydantic models, define database schemas' to improve specificity.
Expand trigger terms to include natural variations like 'REST API', 'Python API', 'web server', 'endpoints', '.py backend' to improve discoverability.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (FastAPI) and some patterns (async patterns, dependency injection, error handling), but doesn't list multiple concrete actions like 'create routes, configure middleware, set up database models'. The actions are more about qualities of the output than specific tasks. | 2 / 3 |
Completeness | Clearly answers both 'what' (create production-ready FastAPI projects with async patterns, dependency injection, error handling) and 'when' (when building new FastAPI applications or setting up backend API projects) with an explicit 'Use when' clause. | 3 / 3 |
Trigger Term Quality | Includes 'FastAPI', 'backend API', and 'API projects' which are relevant keywords, but misses common variations users might say like 'REST API', 'Python API', 'web server', 'endpoints', 'ASGI', or 'uvicorn'. | 2 / 3 |
Distinctiveness Conflict Risk | FastAPI is a specific framework, making this clearly distinguishable from general Python skills, Django skills, or Flask skills. The triggers are distinct enough to avoid conflicts with other skills. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
37%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides excellent, executable code examples covering a full FastAPI application stack, but it is far too verbose for a SKILL.md file—most of the implementation code should live in referenced files. It lacks a clear step-by-step workflow for actually creating a project, and the introductory sections explain concepts Claude already understands. The content would benefit greatly from being restructured as a concise overview with pointers to detailed reference files.
Suggestions
Move the bulk of implementation code (repository pattern, service layer, auth, testing) into the referenced files (e.g., references/fastapi-architecture.md, assets/project-template/) and keep only a minimal quick-start example in SKILL.md.
Add a clear numbered workflow: 1) Create project structure, 2) Set up config/database, 3) Create models/schemas, 4) Implement repository+service, 5) Add routes, 6) Run tests to validate—with explicit validation checkpoints at each stage.
Remove the 'Core Concepts' section and 'When to Use This Skill' list entirely—Claude knows what DI, async patterns, and FastAPI are.
Remove the 'Common Pitfalls' bullet list of obvious advice (e.g., 'No Testing: Skipping integration tests') that doesn't add actionable value.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~400+ lines. Explains concepts Claude already knows well (what dependency injection is, what async patterns are, what CRUD is). The 'Core Concepts' section is entirely unnecessary preamble. The 'When to Use This Skill' section lists obvious use cases. Multiple complete class implementations could be condensed significantly or moved to reference files. | 1 / 3 |
Actionability | The code examples are concrete, executable, and copy-paste ready. Complete implementations are provided for the repository pattern, service layer, endpoints, authentication, database setup, and testing fixtures with real imports and proper async patterns. | 3 / 3 |
Workflow Clarity | There is no clear sequenced workflow for setting up a project. The patterns are presented as isolated code blocks without a step-by-step process for creating a new project. No validation checkpoints exist (e.g., verify database connection works, run tests after setup, validate migrations). For a skill involving project creation with database setup, this is a significant gap. | 1 / 3 |
Progressive Disclosure | References to external files exist in the Resources section (architecture guide, async best practices, testing strategies, project template), but the main file is a monolithic wall of code that should have most of its content in those referenced files. The inline content is far too long for an overview/SKILL.md. | 2 / 3 |
Total | 7 / 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 |
|---|---|---|
skill_md_line_count | SKILL.md is long (568 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- Dicklesworthstone/pi_agent_rust
- Commit
47823e3
- 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.