jbvc/rag-implementation
Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.
65
65%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Risky
Do not use without reviewing
Quality
Discovery
89%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 skill description with strong trigger terms and clear completeness via an explicit 'Use when' clause. Its main weakness is that the 'what' portion could be more specific about concrete actions (e.g., chunking documents, generating embeddings, configuring vector stores, building retrieval pipelines) rather than staying at the architectural level.
Suggestions
Add more concrete actions to the capability list, e.g., 'chunk documents, generate embeddings, configure vector stores, build retrieval pipelines' to improve specificity.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (RAG systems) and some actions ('build', 'implementing', 'integrating'), but doesn't list multiple concrete specific actions like chunking strategies, embedding generation, vector store configuration, or retrieval pipeline setup. | 2 / 3 |
Completeness | Clearly answers both 'what' (build RAG systems with vector databases and semantic search) and 'when' (explicit 'Use when' clause covering knowledge-grounded AI, document Q&A systems, and integrating LLMs with external knowledge bases). | 3 / 3 |
Trigger Term Quality | Good coverage of natural terms users would say: 'RAG', 'Retrieval-Augmented Generation', 'vector databases', 'semantic search', 'document Q&A', 'knowledge bases', 'LLM applications'. These are terms users naturally use when seeking this capability. | 3 / 3 |
Distinctiveness Conflict Risk | RAG systems, vector databases, and semantic search form a clear niche that is unlikely to conflict with other skills. The combination of these specific technologies creates a distinct trigger profile. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
22%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is a comprehensive but bloated reference document rather than a focused, actionable guide. It catalogs many options and patterns Claude already knows about (vector databases, embedding models, retrieval strategies) without providing clear workflow guidance or validation steps. The code examples are a strength but are undermined by undefined helper functions and deprecated APIs, and the sheer volume of content makes it hard to follow as a skill.
Suggestions
Cut the 'Core Components' catalog section entirely—Claude knows what Pinecone, Weaviate, and embedding models are. Keep only the Quick Start and one or two advanced patterns inline, moving the rest to referenced files.
Replace the vague 4-step 'Instructions' with a concrete workflow that includes validation checkpoints, e.g., 'After indexing, run a test query to verify retrieval quality before building the full chain.'
Move vector store configurations, chunking strategies, and advanced patterns into the referenced files (references/*.md) and keep SKILL.md as a concise overview with the Quick Start example.
Fix incomplete code: define or remove placeholder functions like `determine_category`, `calculate_accuracy`, `evaluate_retrieved_docs`, and `check_groundedness` to make examples truly executable.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~300+ lines. Lists multiple vector databases, embedding models, retrieval strategies, and chunking methods that Claude already knows. The 'Core Components' section is essentially a catalog of options that adds little actionable value. Much of this is reference material that should be in separate files or omitted entirely. | 1 / 3 |
Actionability | Provides executable code examples using LangChain that are mostly copy-paste ready, which is good. However, many code snippets are incomplete (e.g., `determine_category` and `calculate_accuracy` are undefined), the evaluation metrics section uses pseudocode-like helper functions, and the Pinecone example uses a deprecated API (`pinecone.init`). The code is functional but has gaps. | 2 / 3 |
Workflow Clarity | The 'Instructions' section lists 4 high-level steps that are too vague to be actionable ('Define the corpus, update cadence, and evaluation targets'). There are no validation checkpoints, no feedback loops for error recovery, and no clear sequencing between the many code examples. For a multi-step process like building a RAG system, the lack of explicit validation steps (e.g., verifying embeddings were created correctly, testing retrieval before deploying) is a significant gap. | 1 / 3 |
Progressive Disclosure | References to external files exist in the 'Resources' section, which is good. However, the main file is monolithic with extensive inline content that should be in those referenced files (e.g., all the vector store configurations, all chunking strategies, all advanced patterns). The skill tries to be both an overview and a comprehensive reference, defeating the purpose of progressive disclosure. | 2 / 3 |
Total | 6 / 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.
Reviewed
Table of Contents