Systematic technical research combining multi-source discovery with evidence-based analysis. Delivers authoritative recommendations backed by credible sources. Use when researching best practices, evaluating technologies, comparing approaches, discovering documentation, troubleshooting with authoritative sources, or when research, documentation, evaluation, comparison, or `--research` are mentioned.
This skill inherits all available tools. When active, it can use any tool Claude has access to.
Systematic investigation → evidence-based analysis → authoritative recommendations.
<when_to_use>
NOT for: quick lookups, well-known patterns, time-critical debugging without investigation phase </when_to_use>
<phases> Track with TodoWrite. Phases advance only, never regress.| Phase | Trigger | activeForm |
|---|---|---|
| Analyze Request | Session start | "Analyzing research request" |
| Discover Sources | Criteria defined | "Discovering sources" |
| Gather Information | Sources identified | "Gathering information" |
| Synthesize Findings | Information gathered | "Synthesizing findings" |
| Compile Report | Synthesis complete | "Compiling report" |
TodoWrite format:
- Analyze Request → { scope definition }
- Discover Sources → { multi-source strategy }
- Gather Information → { key areas }
- Synthesize Findings → { comparison/evaluation }
- Compile Report → { deliverable type }
Situational (insert when triggered):
Workflow:
in_progresscompleted, add next in_progress△ Caveats
</phases>
1. Question Phase — Define scope and success criteria
Query types:
2. Discovery Phase — Multi-source retrieval
Source selection by use case:
| Use Case | Primary | Secondary | Tertiary |
|---|---|---|---|
| Official docs | context7 | octocode | firecrawl |
| Troubleshooting | octocode issues | firecrawl community | context7 guides |
| Code examples | octocode repos | firecrawl tutorials | context7 examples |
| Technology eval | Parallel all | Cross-reference | Validate |
Progressive pattern:
octocode.packageSearch + context7.resolve-library-idcontext7.get-library-docs + octocode.githubSearchCode + firecrawl.search3. Evaluation Phase — Analyze against criteria
| Criterion | Metrics |
|---|---|
| Performance | Benchmarks, latency, throughput, memory |
| Maintainability | Code complexity, docs quality, community activity |
| Security | CVEs, audits, compliance (OWASP, CWE) |
| Adoption | Downloads, production usage, industry patterns |
| Ecosystem | Integrations, plugins, tooling |
Source authority hierarchy:
4. Comparison Phase — Systematic tradeoff analysis
Comparison matrix:
| Criterion | Option A | Option B | Option C |
|-------------|----------|----------|----------|
| Performance | 10k/s | 15k/s | 8k/s |
| Learning | Moderate | Steep | Gentle |
| Ecosystem | Large | Medium | Small |
For each option document:
5. Recommendation Phase — Clear guidance with rationale
Structure:
| Query Type | Budget | Reduction |
|---|---|---|
| Quick Reference | 800 | 85% |
| Installation | 1200 | 80% |
| Troubleshooting | 1500 | 75% |
| Comprehensive | 2000 | 70% |
Techniques:
Validation before output:
context7 — Official library documentation
resolve-library-id(name) → get doc IDget-library-docs(id, topic) → focused retrievaloctocode — GitHub repository intelligence
packageSearch(name) → repo metadatagithubSearchCode(query) → real implementationsgithubSearchIssues(query) → troubleshootinggithubViewRepoStructure(owner/repo) → structurefirecrawl — Web documentation and community
search(query) → web resultsscrape(url, formats=['markdown']) → extract contentmap(url) → discover structure before crawlingonlyMainContent=true, maxAge for cachingParallel execution pattern:
await Promise.all([
context7.resolve(name),
octocode.packageSearch(name),
firecrawl.search(query)
]).then(consolidateResults)
Fallback chain:
context7 fails → octocode issues → firecrawl alternatives
Empty docs → broader topic → web search
Rate limit → alternate MCP → manual search guidance
</tools>
<discovery_patterns> Library Installation
octocode.packageSearch(name) → repo, version, depscontext7.resolve-library-id(name) → doc IDcontext7.get-library-docs(id, topic="installation") → official guideError Resolution
octocode.githubSearchIssues(pattern) → related issuescontext7.get-library-docs(id, topic="troubleshooting") → official fixesfirecrawl.search(error_message) → community solutionsAPI Exploration
context7.resolve-library-id(name) → doc IDcontext7.get-library-docs(id, topic="api") → referenceoctocode.githubSearchCode(examples) → real usageTechnology Comparison
<findings_format> Two output modes based on research type:
Evaluation Mode (claims and recommendations):
Finding: { assertion or claim }
Source: { authoritative source with link }
Confidence: High/Medium/Low — { brief rationale }
Verify: { how to validate this finding }
Discovery Mode (searching and gathering):
Found: { what was discovered }
Source: { where it came from with link }
Notes: { relevant context or caveats }
Use Evaluation Mode when making recommendations or assertions. Use Discovery Mode when gathering options or looking things up. Mix modes as appropriate within a single research session. </findings_format>
<response_structure>
## Research Summary
Brief overview — what investigated, methodology, sources consulted.
## Options Discovered
1. **Option A** — description, key characteristics
2. **Option B** — description, key characteristics
3. **Option C** — description, key characteristics
## Comparison Matrix
| Criterion | Option A | Option B | Option C |
|-----------|----------|----------|----------|
| Key metrics for easy comparison |
## Recommendation
### Primary: [Option Name]
**Rationale**: Detailed reasoning + supporting evidence
**Strengths**:
- Specific advantages with quantified data when available
**Tradeoffs**:
- Acknowledged limitations and considerations
**Confidence**: High/Medium/Low with explanation
### Alternatives
When primary may not fit:
- Scenario X → Consider Option Y because...
## Implementation Guidance
**Next Steps**:
1. Specific action items
2. Configuration recommendations
3. Validation criteria
**Common Pitfalls**:
- Pitfall 1 → How to avoid
- Pitfall 2 → How to avoid
**Migration** (if applicable):
- Path from current to recommended
## Authoritative Sources
- **Official Docs**: [Direct links]
- **Benchmarks**: [Performance comparisons]
- **Case Studies**: [Real-world examples]
- **Community**: [Discussions, blog posts]
---
> Context Usage: XXX tokens (XX% compression achieved)
> Sources: context7 | octocode | firecrawl
</response_structure>
<quality> Always include: - Direct citations to authoritative sources with links - Quantified comparisons when available (metrics, statistics) - Acknowledged limitations and edge cases - Context about when recommendations may not apply - Confidence levels and areas needing further investigationAlways validate:
Always consider:
Outdated Patterns
User mentions deprecated approach
→ Flag deprecation
→ Suggest modern alternative
→ Provide migration path
Missing Prerequisites
Feature requires setup
→ Include prerequisite steps
→ Validate environment requirements
→ Provide configuration guidance
Common Pitfalls
Topic has known gotchas
→ Add prevention notes
→ Include troubleshooting tips
→ Reference common issues
Related Tools
Solution has complementary tools
→ Mention related libraries
→ Explain integration patterns
→ Provide ecosystem context
</proactive>
<rules>
ALWAYS:
- Create "Analyze Request" todo at session start
- Update todos when transitioning phases
- One phase `in_progress` at a time
- Mark phases `completed` before advancing
- Use multi-source approach (context7, octocode, firecrawl)
- Provide direct citations with links
- Cross-reference critical information
- Include confidence levels and limitations
- Validate code examples are complete and runnable
- Achieve target token compression for query type
NEVER: