agent-dev-backend-api
Agent skill for dev-backend-api - invoke with $agent-dev-backend-api
33
0%
Does it follow best practices?
Impact
85%
1.08xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./.agents/skills/agent-dev-backend-api/SKILL.mdQuality
Discovery
0%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 description is essentially a label and invocation instruction rather than a functional description. It provides zero information about what the skill does, what technologies or actions it covers, or when it should be selected. It would be nearly impossible for Claude to correctly choose this skill from a pool of available options.
Suggestions
Replace the entire description with concrete actions the skill performs, e.g., 'Creates and modifies backend API endpoints, configures routes, handles authentication middleware, and manages database models.'
Add an explicit 'Use when...' clause with natural trigger terms, e.g., 'Use when the user asks about building REST APIs, creating endpoints, setting up Express/FastAPI routes, or working with backend server code.'
Include specific technologies, frameworks, or file types the skill handles (e.g., Node.js, Python, Django, Flask, Express, .py, .js) to improve distinctiveness and trigger matching.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description contains no concrete actions whatsoever. 'Agent skill for dev-backend-api' is entirely vague and does not describe what the skill actually does. | 1 / 3 |
Completeness | Neither 'what does this do' nor 'when should Claude use it' is answered. The description only states it's an 'agent skill' and how to invoke it, providing no functional or contextual information. | 1 / 3 |
Trigger Term Quality | There are no natural keywords a user would say. 'dev-backend-api' is an internal identifier, not a term users would naturally use in requests. No mention of backend, API development, endpoints, REST, or any other relevant terms. | 1 / 3 |
Distinctiveness Conflict Risk | The description is so vague that it could overlap with any backend or API-related skill. There are no distinct triggers or specific capabilities to differentiate it from other skills. | 1 / 3 |
Total | 4 / 12 Passed |
Implementation
0%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is fundamentally flawed: it consists primarily of aspirational framework documentation for a fictional 'Agentic-Flow v2.0.0-alpha' system with non-existent APIs (reasoningBank, agentDB, GNN search). It provides no actionable guidance for actual backend API development—no real commands, no executable code, no concrete workflows. The enormous YAML frontmatter appears to be incorrectly included in the body content, and the TypeScript examples are pure fantasy code that Claude cannot execute.
Suggestions
Remove all fictional framework API code (reasoningBank, agentDB, flashAttention, GNN search) and replace with concrete, executable examples of actual API development tasks (e.g., creating an Express route, writing a controller, setting up middleware).
Add a clear, sequenced workflow for common API development tasks with validation checkpoints (e.g., 1. Create route file, 2. Implement controller, 3. Add validation middleware, 4. Run tests to verify, 5. If tests fail, fix and re-run).
Reduce content by 70%+ by removing the massive YAML frontmatter from the body, eliminating explanations of basic concepts Claude already knows (REST, CRUD, HTTP status codes), and focusing only on project-specific patterns and conventions.
Provide concrete, copy-paste-ready code examples showing the actual file structure, naming conventions, and patterns specific to this project rather than generic best practices lists.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose with massive YAML frontmatter that bleeds into the body, extensive TypeScript code blocks demonstrating hypothetical framework APIs (reasoningBank, agentDB, flashAttention) that are not real executable tools, and explains concepts Claude already understands like REST CRUD patterns and HTTP status codes. The 'self-learning protocol' sections are aspirational framework documentation, not actionable skill instructions. | 1 / 3 |
Actionability | The TypeScript code blocks are not executable—they reference fictional APIs (reasoningBank.searchPatterns, agentDB.gnnEnhancedSearch, agentDB.flashAttention) that don't exist as real tools Claude can use. There are no concrete, copy-paste-ready commands for actual API development tasks. The 'best practices' and 'key responsibilities' sections are vague bullet-point lists without specific implementation guidance. | 1 / 3 |
Workflow Clarity | There is no clear, sequenced workflow for performing actual backend API development tasks. The 'Before/During/After Implementation' sections describe a hypothetical self-learning loop using non-existent tools rather than concrete development steps. No validation checkpoints, no error recovery feedback loops for actual API development work. | 1 / 3 |
Progressive Disclosure | The content is a monolithic wall of text with no references to external files and no bundle files provided. The massive YAML frontmatter (which appears to be incorrectly placed inside the body content) combined with lengthy TypeScript pseudo-examples creates poor organization. There's no clear hierarchy or navigation structure. | 1 / 3 |
Total | 4 / 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.
- Repository
- ruvnet/claude-flow
- Commit
9d4a9ea
- 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.