knowledge-discovery
Discover relevant skills and knowledge using tiered approach. SKIP for simple tasks, QUICK for single-skill, STANDARD for multi-skill, DEEP for full feature implementation. Auto-selects tier based on task complexity.
When & Why to Use This Skill
This Claude skill implements an adaptive knowledge discovery protocol that optimizes agent efficiency by matching task complexity with tiered research depths. By intelligently selecting between SKIP, QUICK, STANDARD, and DEEP tiers, it ensures the agent utilizes the precise amount of context and skill-loading required—minimizing latency for simple edits while providing comprehensive multi-step discovery for complex feature implementations.
Use Cases
- Task Complexity Assessment: Automatically determining if a request is a simple typo fix (SKIP) or a full feature implementation (DEEP) to save time and tokens.
- Framework Pattern Mapping: Rapidly identifying and applying specific technical patterns like ABP Framework, EF Core, or FluentValidation for single-skill tasks.
- Multi-Skill Orchestration: Coordinating the discovery of related skills and dependencies for complex architectural tasks such as API design or security auditing.
- Error-to-Skill Resolution: Mapping specific runtime errors (e.g., N+1 queries or authorization failures) to the exact optimization or debugging skills needed for a fix.
- Layered Skill Loading: Managing the sequential loading of foundational, framework, and feature-level skills to ensure stable and context-aware code generation.
| name | knowledge-discovery |
|---|---|
| description | "Discover relevant skills and knowledge using tiered approach. SKIP for simple tasks, QUICK for single-skill, STANDARD for multi-skill, DEEP for full feature implementation. Auto-selects tier based on task complexity." |
| layer | 4 |
| tech_stack | [agnostic] |
| topics | [discovery, index, skills, knowledge, flows, context7, efficiency] |
| depends_on | [] |
| complements | [] |
| keywords | [discover, find, search, related, skills, knowledge, workflow, flow, tier, quick] |
Knowledge Discovery
Adaptive discovery skill with tiered efficiency for different task complexities.
Discovery Tiers
| Tier | When to Use | Files Read | Time Cost |
|---|---|---|---|
| SKIP | Simple/obvious tasks, single file edits | 0 | ~0s |
| QUICK | Single-skill tasks, known patterns | Quick ref only | ~2s |
| STANDARD | Multi-skill tasks, unfamiliar patterns | INDEX + GRAPH | ~10s |
| DEEP | Full feature implementation, CRUD flows | All 4 steps | ~15-20s |
Tier Selection Guide
START: What's the task?
│
├─ "Fix typo" / "Add comment" / "Simple edit"
│ └─ SKIP (no discovery needed)
│
├─ "Write tests" / "Add validation" / "Single pattern"
│ └─ QUICK (use inline reference below)
│
├─ "Design API" / "Debug error" / "Multi-step task"
│ └─ STANDARD (read SKILL-INDEX + CONTEXT-GRAPH)
│
└─ "Implement CRUD" / "Add feature" / "Full workflow"
└─ DEEP (full 4-step protocol)
QUICK Tier: Inline Reference
Use this for single-skill tasks without reading any files:
| Task | Skill | No Lookup Needed |
|---|---|---|
| Entity/DTO/AppService | abp-framework-patterns |
✓ |
| DbContext/Migration | efcore-patterns |
✓ |
| Input validation | fluentvalidation-patterns |
✓ |
| Permissions/Auth | openiddict-authorization |
✓ |
| Unit/Integration tests | xunit-testing-patterns |
✓ |
| E2E tests | e2e-testing-patterns |
✓ |
| Query optimization | linq-optimization-patterns |
✓ |
| API design | api-design-principles |
✓ |
| Technical design doc | technical-design-patterns |
✓ |
| Debug/errors | debugging-patterns |
✓ |
| Docker/.NET | docker-dotnet-containerize |
✓ |
| Git advanced | git-advanced-workflows |
✓ |
| Security audit | security-patterns |
✓ |
Common Error → Skill:
| Error | Skill |
|---|---|
| N+1 query | linq-optimization-patterns |
| Authorization failed | openiddict-authorization |
| Validation failed | fluentvalidation-patterns |
| DbUpdateException | efcore-patterns |
| Task was canceled | dotnet-async-patterns |
STANDARD Tier Protocol
For multi-skill tasks, read these files:
1. DISCOVER → Check SKILL-INDEX.md for relevant skills
2. RELATE → Check CONTEXT-GRAPH.md for dependencies
DEEP Tier Protocol
For full feature implementation:
1. DISCOVER → Check SKILL-INDEX.md for relevant skills
2. RELATE → Check CONTEXT-GRAPH.md for dependencies
3. REFERENCE → Read /knowledge/ for shared patterns
4. FOLLOW → Use /flows/ for multi-step workflows
Discovery by Task Type
Creating a New Entity/Feature
- Check flow: flows/crud-implementation.md
- Primary skills:
abp-framework-patterns,efcore-patterns,fluentvalidation-patterns - Knowledge:
Adding Validation
- Primary skill:
fluentvalidation-patterns - Knowledge:
Implementing Authorization
- Primary skill:
openiddict-authorization - Related:
security-patterns,abp-framework-patterns - Knowledge: knowledge/conventions/permissions.md
Writing Tests
- Primary skill:
xunit-testing-patterns - Knowledge:
Debugging an Error
- Check index: Search error message in SKILL-INDEX.md (Error Message section)
- Primary skill:
debugging-patterns - Related: Check skill by keyword match
Designing an API
- Primary skills:
api-design-principles,technical-design-patterns - Related:
domain-modeling,requirements-engineering
Optimizing Queries
- Primary skill:
linq-optimization-patterns - Related:
efcore-patterns - Check index: Search "N+1" in SKILL-INDEX.md
Skill Layer Loading
Load skills in dependency order:
Layer 1 (Foundations) → Load first
csharp-advanced-patterns, dotnet-async-patterns, error-handling-patterns
Layer 2 (Framework) → Load second
abp-framework-patterns, efcore-patterns, fluentvalidation-patterns
Layer 3 (Features) → Load third
xunit-testing-patterns, security-patterns, distributed-events
Layer 4 (Workflows) → Load as needed
feature-development-workflow
Index Files Reference
| File | Purpose | Location |
|---|---|---|
| SKILL-INDEX.md | Find skills by task/keyword/error | SKILL-INDEX.md |
| CONTEXT-GRAPH.md | Skill dependencies, layers, relationships | CONTEXT-GRAPH.md |
| knowledge/INDEX.md | Shared patterns and conventions | knowledge/INDEX.md |
| flows/INDEX.md | Multi-step workflows | flows/INDEX.md |
Quick Lookup Commands
By Task
"I need to create an entity" → abp-framework-patterns + efcore-patterns
"I need to validate input" → fluentvalidation-patterns
"I need to add permissions" → openiddict-authorization
"I need to write tests" → xunit-testing-patterns
"I need to optimize queries" → linq-optimization-patterns
By Error
"N+1 query" → linq-optimization-patterns
"Authorization failed" → openiddict-authorization
"Validation failed" → fluentvalidation-patterns
"DbUpdateException" → efcore-patterns
By Keyword
"Entity" → abp-framework-patterns
"DbContext" → efcore-patterns
"FluentValidation" → fluentvalidation-patterns
"[Authorize]" → openiddict-authorization
"xUnit" → xunit-testing-patterns
Integration
This skill should be invoked:
- Automatically at the start of complex tasks
- When the user asks "what skills do I need for..."
- Before implementing multi-step workflows
- When encountering unfamiliar patterns or errors
Related Skills
After discovery, typically load:
abp-framework-patterns- Core ABP patternsefcore-patterns- Database layerfluentvalidation-patterns- Input validationopeniddict-authorization- Permissionsxunit-testing-patterns- Testing