copilot-search

# Copilot Search Skill

Use Claude Code's web search capabilities combined with GitHub Copilot CLI to research current information, documentation, and solutions. This is a **read-only research** skill.

## When to Use

- User asks "what's the best library for X?"
- User needs current documentation or API references
- User wants to compare different libraries or approaches
- User has an error message and needs solutions
- User asks about best practices or security recommendations
- User wants to learn about a new technology or framework
- User needs to find tutorials or getting started guides

## Important Note

**GitHub Copilot CLI does not have built-in web search capabilities.** This skill uses:

- **WebSearch** and **WebFetch** tools for web research (primary)
- **Copilot CLI** for code analysis and contextualization (optional)

## Prerequisites

Verify Copilot CLI is available (optional for local context):

```bash
copilot --version  # Should display installed version
```

Ensure you have internet connectivity for web search.

## Basic Usage

### Step 1: Parse the Research Need

Extract what the user wants to know:

- Specific technology or library?
- What aspect (documentation, comparison, best practices)?
- Any version requirements?
- Context from current project?

### Step 2: Gather Local Context (Optional)

Check current project context if relevant:

```bash
# Check current dependencies
cat package.json  # or requirements.txt, go.mod, etc.

# Check versions in use
npm list --depth=0  # or pip list, go list, etc.

# Check git status
git status
git log --oneline -5
```

Use Read, Grep, Glob to understand existing patterns.

### Step 3: Execute Web Search

Use the **WebSearch** tool for broad research:

```
Query: "[TOPIC] latest documentation 2026"
Query: "best practices for [TECHNOLOGY] security 2026"
Query: "[ERROR_MESSAGE] solution [FRAMEWORK] [VERSION]"
```

**Search strategies:**

- Be specific about what you're looking for
- Include version numbers if known
- Specify "latest" or "2026" for current info
- Request official sources when possible
- Include framework/language context

**Example queries:**

```
"Next.js 15 authentication best practices 2026"
"React useEffect cleanup function official documentation"
"TypeScript generic constraints examples"
"Python async/await security vulnerabilities 2026"
```

### Step 4: Fetch and Verify Sources

Use **WebFetch** to retrieve specific documentation:

```
URL: https://nextjs.org/docs/app/building-your-application/authentication
Prompt: "Extract authentication best practices, code examples, and security recommendations"

URL: https://react.dev/reference/react/useEffect
Prompt: "Find cleanup function usage, common patterns, and gotchas"
```

**Verification steps:**

- Check publication dates (prefer recent sources)
- Verify information from official documentation
- Cross-reference multiple sources for controversial topics
- Look for version-specific information
- Check for deprecation warnings

### Step 5: Optional - Use Copilot CLI for Context

If needed, use Copilot CLI to understand how findings apply to the current codebase:

```bash
copilot
```

Then ask:

```
Based on the current codebase patterns, how would we implement [SOLUTION_FROM_SEARCH]?

Context from web search:
- [Key findings]
- [Recommended approach]
- [Code examples]

Analyze the current codebase and suggest how to integrate this approach.
Do NOT make changes - analysis only.
```

### Step 6: Present Results

Format the response with proper citations:

````markdown
## Research: [Topic]

### Summary

[Direct answer with key findings in 2-3 sentences]

### Official Documentation

- [Library Name - Topic](https://official-url) - Official reference
- [API Docs](https://api-url) - API documentation

### Key Findings

**Best Practices:**

1. [Practice] - [Explanation] ([Source URL])
2. [Practice] - [Explanation] ([Source URL])

**Common Pitfalls:**

- [Issue] - [How to avoid] ([Source URL])

**Recommendations:**

- [Recommendation with reasoning]

### Code Examples

```language
// Source: [URL]
// Example: [Description]
[Working code example]
```

### Alternative Approaches

| Approach   | Pros | Cons | Use When |
| ---------- | ---- | ---- | -------- |
| [Option 1] | ...  | ...  | ...      |
| [Option 2] | ...  | ...  | ...      |

### Integration Notes

[If Copilot CLI was used, include local context here]

- Current patterns: [What exists]
- Suggested approach: [How to integrate]
- Files to modify: [Specific paths]

### Sources

All information sourced from:

1. [Title](URL) - [Description]
2. [Title](URL) - [Description]
3. [Title](URL) - [Description]

Last verified: [Current date]
````

## Example Queries

### Documentation Lookup

```
WebSearch query: "React hooks official documentation 2026"
WebFetch URL: https://react.dev/reference/react
Prompt: "Extract useState, useEffect, useContext documentation with examples"
```

### Library Comparison

```
WebSearch query: "Prisma vs TypeORM vs Drizzle comparison TypeScript 2026"
WebFetch: Official docs for each library
Create comparison table from findings
```

### Error Resolution

```
WebSearch query: "ECONNREFUSED Node.js solution 2026"
WebSearch query: "ECONNREFUSED common causes troubleshooting"
Verify solutions from multiple sources
```

### Best Practices

```
WebSearch query: "JWT authentication security best practices OWASP 2026"
WebFetch: https://owasp.org (if applicable)
WebFetch: Official framework security docs
```

### Getting Started

```
WebSearch query: "Next.js 15 getting started tutorial 2026"
WebFetch: https://nextjs.org/learn
Extract setup, core concepts, first app tutorial
```

## Best Practices

✅ **DO:**

- Always use WebSearch for broad queries
- Use WebFetch to verify official sources
- Include URLs for all sources
- Prefer official documentation over blog posts
- Verify information is current (2025-2026)
- Cross-reference multiple sources
- Note when information is version-specific
- Include security considerations
- Use Copilot CLI for local codebase context (optional)

❌ **DON'T:**

- Make or suggest code changes (use copilot-exec for that)
- Trust outdated information (pre-2024 for fast-moving tech)
- Rely on single sources
- Present unverified information
- Skip source attribution
- Ignore official documentation
- Modify code (this is read-only research)

## Source Evaluation

**Prioritize:**

- Official documentation and guides
- Official GitHub repositories
- CVE databases and security advisories
- MDN (for web standards)
- OWASP (for security)
- RFC specifications
- Major framework official blogs

**Verify:**

- Stack Overflow (check dates, votes)
- Reputable tech blogs
- GitHub issues
- Conference talks

**Use with caution:**

- Personal blogs (unless from known experts)
- Old tutorials (pre-2024)
- Unverified forum posts

## Error Handling

**If WebSearch returns no results:**

- Simplify the query
- Try alternative keywords
- Search for related concepts
- Use broader terms

**If results are outdated:**

- Explicitly request "2026" or "latest" in query
- Use WebFetch to check official docs directly
- Ask for recent comparisons

**If results conflict:**

- Search for official stance
- Check version-specific differences
- Verify dates and determine which is current
- Prefer official documentation

**If Copilot not found (optional):**

```
Copilot CLI is not available. Continuing with web search only.
Install: https://github.com/github/copilot-cli
```

## Integration with Codebase

After gathering information:

1. **Assess applicability** to current project
2. **Check compatibility** with existing dependencies
3. **Plan implementation** steps if adopting findings
4. **Suggest testing** approach

Example:

```bash
# After researching a library, check compatibility
npm info [package]@latest peerDependencies
npm install [package]@latest --dry-run
```

## Related Skills

- **copilot-ask**: For understanding existing code in your codebase
- **copilot-exec**: For implementing solutions found through research
- **copilot-review**: For validating code quality after implementation

## Use Cases

### Technology Evaluation

Research before choosing a library or framework:

```
WebSearch query: "GraphQL vs REST vs tRPC TypeScript API comparison 2026"
```

### Migration Planning

Find migration guides and breaking changes:

```
WebSearch query: "Vue 2 to Vue 3 migration guide breaking changes"
WebFetch: Official Vue migration documentation
```

### Security Research

Find vulnerabilities and best practices:

```
WebSearch query: "express 4.18 security vulnerabilities CVE 2026"
WebFetch: GitHub Security Advisories
WebFetch: npm security advisories
```

### Learning

Get tutorials and learning resources:

```
WebSearch query: "TypeScript beginner tutorial 2026 official"
WebFetch: https://www.typescriptlang.org/docs/handbook/
```

### Troubleshooting

Research error messages and solutions:

```
WebSearch query: "Module not found webpack 5 solution"
Cross-reference Stack Overflow and official docs
```

## Advanced Usage

### Multi-Query Research

For complex research, break into focused queries:

```
# Query 1: Current state
WebSearch: "current best practice for SSR in React 2026"

# Query 2: Specific implementation
WebFetch: Official React Server Components documentation

# Query 3: Gotchas
WebSearch: "React Server Components common problems solutions"
```

### Version-Specific Research

```
WebSearch: "TypeScript 5.5 new features changelog"
WebFetch: Official TypeScript release notes
Compare with current project TypeScript version
```

### Comparison Research

```
WebSearch: "Vite vs webpack vs Turbopack 2026 benchmarks"
WebFetch: Official documentation for each tool
Create comparison table with pros/cons
```

### Local Context with Copilot CLI

```bash
# After web research, use Copilot for local context
copilot
```

```
I found these approaches for [TOPIC] from web research:
1. [Approach A] - [Description]
2. [Approach B] - [Description]

Analyze our current codebase:
- Which approach aligns with our patterns?
- What files would need modification?
- Are there any compatibility issues?

Provide file references and recommendations.
Do NOT make changes - analysis only.
```

## Limitations

- Requires internet connectivity for WebSearch/WebFetch
- Search quality depends on available online information
- May return outdated info if not explicitly filtered
- Cannot execute or test code
- Cannot make code modifications
- Limited to publicly available information
- Copilot CLI cannot perform web searches (only local code analysis)

## Tips for Better Results

1. **Be specific**: "What's the best React state management library for large apps?" vs "What's good for state?"
2. **Include context**: "For a Next.js 15 app with TypeScript..."
3. **Request sources**: "Include official documentation and recent comparisons"
4. **Specify timeframe**: "Current best practices in 2026"
5. **Define scope**: "Focus on security best practices"

---

**Remember**: This skill is READ-ONLY research using WebSearch and WebFetch as primary tools, with optional Copilot CLI for local codebase context. Always cite sources and verify information is current. For code modifications, use the `copilot-exec` skill.