From daffy0208-ai-dev-standards
Design, build, and maintain comprehensive knowledge bases. Bridges document-based (RAG) and entity-based (graph) knowledge systems. Use when building knowledge-intensive applications, managing organizational knowledge, or creating intelligent information systems.
npx claudepluginhub joshuarweaver/cascade-content-creation-misc-1 --plugin daffy0208-ai-dev-standardsThis skill uses the workspace's default tool permissions.
Build and maintain high-quality knowledge bases for AI systems and human consumption.
Creates isolated Git worktrees for feature branches with prioritized directory selection, gitignore safety checks, auto project setup for Node/Python/Rust/Go, and baseline verification.
Executes implementation plans in current session by dispatching fresh subagents per independent task, with two-stage reviews: spec compliance then code quality.
Dispatches parallel agents to independently tackle 2+ tasks like separate test failures or subsystems without shared state or dependencies.
Build and maintain high-quality knowledge bases for AI systems and human consumption.
Knowledge Base = Structured Information + Quality Curation + Accessibility
A knowledge base is not just a data dump—it's curated, validated, versioned information designed to answer questions and enable reasoning.
What it is: Collection of documents, chunked and embedded for semantic search
Best for:
Strengths:
Weaknesses:
Use: rag-implementer skill + vector-database-mcp
What it is: Network of entities (people, places, things) connected by relationships
Best for:
Strengths:
Weaknesses:
Use: knowledge-graph-builder skill + graph-database-mcp
What it is: Documents for unstructured knowledge + Graph for structured entities/relationships
Best for:
Strengths:
Weaknesses:
Use: Both rag-implementer + knowledge-graph-builder skills
What kind of knowledge do you have?
├─ Mostly unstructured text (docs, articles, content)?
│ └─ Document-Based KB (RAG)
│ Use: rag-implementer skill
│
├─ Mostly structured entities with relationships?
│ └─ Entity-Based KB (Graph)
│ Use: knowledge-graph-builder skill
│
└─ Mix of both?
└─ Hybrid KB (RAG + Graph)
Use: Both skills + This skill for integration
Goal: Understand what knowledge exists and how to structure it
Actions:
Inventory existing knowledge sources
Classify knowledge types
Choose KB architecture
Define knowledge schema
Validation:
Goal: Transform raw information into high-quality knowledge
Actions:
Extract knowledge from sources
Clean and normalize
Structure knowledge
Add provenance
Curation Best Practices:
Validation:
Goal: Implement technical infrastructure for knowledge access
Architecture Patterns:
For Document-Based KB:
// Vector database for semantic search
interface DocumentKB {
store: 'Pinecone' | 'Weaviate' | 'pgvector'
chunks: {
content: string
embedding: number[]
metadata: {
source: string
title: string
updated_at: string
category: string
}
}[]
}
For Entity-Based KB:
// Graph database for relationship queries
interface EntityKB {
store: 'Neo4j' | 'ArangoDB'
nodes: {
id: string
type: 'Person' | 'Organization' | 'Product' | 'Concept'
properties: Record<string, any>
}[]
relationships: {
from: string
to: string
type: string
properties: Record<string, any>
}[]
}
For Hybrid KB:
// Both vector DB + graph DB
interface HybridKB {
vectorDB: DocumentKB
graphDB: EntityKB
linker: {
// Links documents to entities mentioned in them
linkDocumentToEntities(docId: string): string[]
// Links entities to documents that mention them
linkEntityToDocuments(entityId: string): string[]
}
}
Actions:
Choose database(s)
Implement search/query layer
Add caching and optimization
Validation:
Goal: Ensure knowledge base accuracy and reliability
Quality Metrics:
Validation Strategies:
1. Test Question Sets Create 100+ test questions with known correct answers:
interface TestQuestion {
question: string
expected_answer: string
category: string
difficulty: 'easy' | 'medium' | 'hard'
}
2. Human Review
3. Automated Checks
4. Continuous Monitoring
interface KBHealthMetrics {
accuracy_score: number // 0-100
coverage_score: number // % questions answered
freshness_score: number // avg days since update
consistency_score: number // % no conflicts
user_satisfaction: number // feedback rating
}
Actions:
Validation:
Goal: Track knowledge changes over time and enable rollback
Why Versioning Matters:
Versioning Strategies:
1. Snapshot Versioning
interface KnowledgeEntry {
id: string
content: string
version: number
created_at: string
updated_at: string
updated_by: string
changelog: string
previous_version?: string // ID of prior version
}
2. Event Sourcing
interface KnowledgeEvent {
event_id: string
entity_id: string
event_type: 'created' | 'updated' | 'deleted'
timestamp: string
changes: {
field: string
old_value: any
new_value: any
}[]
author: string
}
3. Git-Style Versioning
Actions:
Validation:
Goal: Keep knowledge base healthy long-term
Maintenance Tasks:
Daily:
Weekly:
Monthly:
Quarterly:
Governance Framework:
1. Roles & Responsibilities
2. Change Process
Submit → Review → Approve → Publish → Monitor
3. Quality Standards
Actions:
Validation:
Problem: Ingesting everything without quality filtering
Impact: Low signal-to-noise ratio, poor search results, user frustration
Solution: Curate before ingesting. Quality > Quantity
Problem: Knowledge changes but no history tracked
Impact: Can't audit changes, can't rollback errors, no accountability
Solution: Implement versioning from Phase 5
Problem: Knowledge base outdated but no one knows
Impact: AI systems hallucinate using old facts, users get wrong answers
Solution: Freshness monitoring + scheduled updates
Problem: Same fact in multiple places, becomes inconsistent
Impact: Conflicting answers, confused users
Solution: Deduplication + single source of truth
Problem: Knowledge without source citations
Impact: Can't verify accuracy, can't trace errors
Solution: Always track source + timestamp + author
Problem: No user validation, KB doesn't meet needs
Solution: Start with user research, validate continuously
Problem: Waiting to launch until KB is "perfect"
Solution: Launch with 80% coverage, iterate based on usage
Problem: Building complex hybrid system when simple docs would work
Solution: Start simple, add complexity only when needed
Problem: Build once, never update
Solution: Establish maintenance schedule from day 1
Before you start:
rag-implementer if using document KBknowledge-graph-builder if using entity KBPhase 1 - Architecture (Week 1):
Phase 2 - Initial Build (Week 2-3):
Phase 3 - Iterate (Ongoing):
rag-implementer, knowledge-graph-builder, data-engineer, quality-auditorvector-database-mcp, graph-database-mcp, knowledge-base-mcp, semantic-search-mcpSTANDARDS/architecture-patterns/rag-pattern.md, knowledge-base-pattern.md (coming soon)INTEGRATIONS/pinecone/, INTEGRATIONS/graph-databases/neo4j/Remember: A knowledge base is only as good as its curation. Invest in quality from day 1, establish maintenance processes, and iterate based on user feedback. The goal is not to have all knowledge—it's to have the right knowledge, well-organized, and easily accessible.