playbook/outfitter-agents/plugins/outfitter/skills/research/references/discovery-patterns.md

Discovery Patterns

Detailed workflows for common research scenarios.

Library Installation

Getting started with a new library.

Workflow

1. Package discovery
2. Documentation retrieval
3. Installation guide
4. Synthesis

Steps

1. Package Discovery

octocode.packageSearch(name)
→ Repository URL
→ Latest version
→ Dependencies
→ Popularity metrics

2. Documentation Retrieval

context7.resolve-library-id(name)
→ Documentation identifier

context7.get-library-docs(id, topic="installation")
→ Official installation guide

3. Installation Synthesis

Compress findings into:

• Prerequisites (runtime, dependencies)
• Installation commands
• Framework-specific integration
• Common pitfalls during setup

Output Structure

## Installation: {Library}

**Prerequisites**:
- {runtime requirement}
- {peer dependencies}

**Install**:
\`\`\`bash
{package manager command}
\`\`\`

**Configuration**:
{minimal config to get started}

**Verify**:
{how to confirm successful installation}

**Common Issues**:
- {issue} → {solution}

Error Resolution

Diagnosing and fixing errors.

Workflow

1. Parse error
2. Search issues
3. Check official docs
4. Find community solutions
5. Synthesize

Steps

1. Parse Error

Extract from error message:
- Error code/type
- Key terms
- Stack trace patterns
- Library/framework context

2. Search Issues

octocode.githubSearchIssues(pattern)
→ Related GitHub issues
→ Resolution status
→ Workarounds

3. Official Troubleshooting

context7.get-library-docs(id, topic="troubleshooting")
→ Known issues
→ Official fixes
→ Migration notes

4. Community Solutions

firecrawl.search(error_message)
→ Stack Overflow answers
→ Blog solutions
→ Forum discussions

5. Synthesis

Rank solutions by:

• Source authority (official > community)
• Recency (newer often better)
• Vote count/acceptance
• Relevance to specific context

Output Structure

## Error: {Error Message/Code}

**Cause**: {root cause explanation}

**Solution** (Recommended):
{step-by-step fix}

**Alternative Solutions**:
1. {alternative approach}
2. {alternative approach}

**Prevention**:
{how to avoid this in future}

**Sources**:
- [GitHub Issue](url)
- [Stack Overflow](url)

API Exploration

Understanding library APIs.

Workflow

1. Get documentation ID
2. Retrieve API reference
3. Find real usage examples
4. Structure findings

Steps

1. Documentation ID

context7.resolve-library-id(name)
→ Documentation identifier

2. API Reference

context7.get-library-docs(id, topic="api")
→ Function signatures
→ Parameters
→ Return types
→ Examples

3. Real Usage

octocode.githubSearchCode("import { functionName } from 'library'")
→ Production usage patterns
→ Common configurations
→ Edge case handling

Output Structure

## API: {Function/Component}

**Signature**:
\`\`\`typescript
{type signature}
\`\`\`

**Parameters**:
| Name | Type | Required | Description |
|------|------|----------|-------------|
| {param} | {type} | {yes/no} | {description} |

**Returns**: {return type and description}

**Example**:
\`\`\`typescript
{usage example}
\`\`\`

**Common Patterns**:
- {pattern}: {when to use}

**Gotchas**:
- {common mistake}

Technology Comparison

Evaluating options for a decision.

Workflow

1. Parallel discovery for each option
2. Cross-reference findings
3. Build comparison matrix
4. Generate recommendation

Steps

1. Parallel Discovery

For each option, simultaneously:

context7: Official documentation, features
octocode: GitHub activity, issues, community
firecrawl: Benchmarks, case studies, reviews

2. Cross-Reference

Compare across sources:

• Feature claims vs reality
• Performance benchmarks
• Community health indicators
• Known limitations

3. Build Matrix

Criterion	Option A	Option B	Option C
Performance	{metric}	{metric}	{metric}
Learning curve	{level}	{level}	{level}
Ecosystem	{size}	{size}	{size}
Maintenance	{status}	{status}	{status}

4. Recommend

Based on:

• User's stated priorities
• Evidence from research
• Trade-off analysis

Output Structure

## Comparison: {Category}

**Options Evaluated**:
1. {Option A} — {brief description}
2. {Option B} — {brief description}

**Matrix**:
| Criterion | Option A | Option B |
|-----------|----------|----------|
| {criterion} | {value} | {value} |

**Recommendation**: {Option}

**Rationale**: {why this option wins for this context}

**When to Choose Alternative**:
- Choose {Option B} when {condition}

**Sources**:
- {source list}

Best Practices Research

Finding recommended approaches.

Workflow

1. Official guidance
2. Expert opinions
3. Community patterns
4. Synthesize with context

Steps

1. Official Guidance

context7.get-library-docs(id, topic="best-practices")
→ Recommended patterns
→ Anti-patterns to avoid
→ Performance tips

2. Expert Opinions

firecrawl.search("{topic} best practices {year}")
→ Expert blog posts
→ Conference talks
→ Industry guides

3. Community Patterns

octocode.githubSearchCode("{pattern}")
→ How production code implements
→ Common approaches
→ Variations

4. Contextualize

Filter recommendations by:

• User's stack/constraints
• Scale requirements
• Team expertise
• Project stage

Output Structure

## Best Practices: {Topic}

**Recommended Approach**:
{primary recommendation}

**Why**:
{rationale with evidence}

**Implementation**:
\`\`\`typescript
{example code}
\`\`\`

**Avoid**:
- {anti-pattern} — {why}

**Context Matters**:
- For {context A}: {variation}
- For {context B}: {variation}

**Sources**:
- [Official Guide](url)
- [Expert Article](url)