Research Powerpack Guide

1. Overview

This skill teaches an AI coding agent how to conduct systematic, multi-source research using the Research Powerpack MCP server. It replaces ad-hoc, single-query searching with structured workflows that produce verified, nuanced, and actionable results.

What this skill does:

Maps any coding research task to the correct combination of 5 specialized tools
Provides workflow patterns that layer tools for depth and cross-validation
Routes 95 use cases across 10 categories to detailed reference files
Eliminates the most common research anti-patterns agents fall into

When to use it:

Any coding task that requires knowledge beyond your training data
Bug fixes where the error message is unfamiliar or ambiguous
Architecture and design decisions that need community validation
Library selection, migration planning, and compatibility checks
Performance investigations, security audits, and DevOps configuration
Any question where the answer could be outdated, contested, or context-dependent

The core insight: No single tool is sufficient. web_search gives you breadth but not content. deep_research gives you synthesis but can hallucinate sources. search_reddit gives you practitioner signal but with survivorship bias. The power comes from layering: use one tool to generate leads, another to extract content, and a third to validate claims. Every research workflow in this guide uses at least 2-3 tools in sequence.

What this skill does NOT do:

It does not contain the full details for all 95 use cases. Those live in the references/ directory. This file is the routing layer and methodology guide.
It does not replace reading official documentation. It helps you find and extract the right parts of official documentation faster.

2. The Five Tools — Quick Reference

Tool Summary Table

Tool	Purpose	Input	Output	When to Use
`web_search`	Breadth-first discovery	3-50 keywords	URLs only (10 per keyword)	Always first. Find where answers live.
`search_reddit`	Community signal	3-50 queries	Post titles + URLs	Find practitioner experiences, warnings, regrets.
`get_reddit_post`	Deep opinion mining	2-50 URLs	Full comment threads	Extract exact recommendations, code, config values.
`deep_research`	Structured synthesis	1-10 questions	32K tokens of analysis	Complex questions needing multi-angle analysis.
`scrape_links`	Content extraction	1-50 URLs	Structured content	Get actual page content from URLs found by other tools.

Tool Details

web_search — The starting gun for every research workflow.

Runs 3-50 parallel Google searches. Recommended: 5-7 keywords.
Returns ~10 URLs per keyword. 7 keywords = 70 candidate URLs.
CRITICAL: Returns URLs only, never content. You MUST follow up with scrape_links.
Supports operators: site:, "exact phrase", -exclude, filetype:, OR.
Each keyword must target a different angle. Never repeat the same query reworded.

search_reddit — The community pulse check.

Runs 3-50 parallel Reddit searches. Recommended: 5-7 queries.
Returns post titles and URLs sorted by relevance.
Supports subreddit targeting: include r/rust, r/typescript in queries.
Supports operators: intitle:, "exact", OR, -exclude.
Best for: finding real-world war stories, failure modes, and migration regrets.

get_reddit_post — The opinion deep dive.

Fetches full comment threads from 2-50 Reddit URLs.
Auto-allocates comment budget: 1000 total (2 posts = 500 each, 10 = 100 each).
Set use_llm=false (the default) to get raw comments with exact quotes and code.
Set use_llm=true ONLY when synthesizing 20+ posts and the user wants a summary.
Best for: extracting specific numbers, config snippets, and dissenting opinions.

deep_research — The structured analyst.

Runs 2-10 parallel research questions. 32K token budget split across questions.
2 questions = 16K tokens each (deep). 5 questions = 6.4K each (balanced).
MUST use the structured template (Section 5 details this).
MUST attach relevant code files for bug/code questions, or answers will be generic.
Best for: architecture decisions, complex debugging, technology evaluation.

scrape_links — The content extractor.

Scrapes 1-50 URLs with AI extraction. Recommended: 3-5 URLs.
32K token budget: 3 URLs = 10K each, 5 = 6K each, 10 = 3K each.
Use pipe-separated extraction targets: "pricing|features|limits|auth|rate-limits".
Default use_llm=true strips navigation, ads, footers — returns only what you ask for.
Best for: extracting structured data from docs, pricing pages, GitHub READMEs.

3. Research Workflow Patterns

These three patterns cover 90% of coding research tasks. Pick the one that matches your situation, then adapt as needed.

Pattern A: Bug Fix Research (most common)

Use when: runtime error, compiler error, crash, unexpected behavior, deprecation warning.

Step 1: web_search (5-7 keywords)
   - Exact error message in "quotes"
   - Error message + framework/language version
   - Error message + "fix" or "solution"
   - Error code (if any) + library name
   - Simplified error description without project-specific paths

Step 2: scrape_links (top 3-5 URLs from Step 1)
   - Extract: "error cause | fix steps | code example | version affected | workarounds"

Step 3: search_reddit (3-5 queries)
   - "[error message]" in relevant subreddit
   - "[library] [symptom]" for broader matches
   - "[library] breaking change [version]" if version-related

Step 4: DONE for most bugs.
   If still unresolved → deep_research with the buggy code file attached.

Total time: 3-4 tool calls. Covers: StackOverflow, GitHub Issues, blogs, Reddit.

Pattern B: Decision / Architecture Research (second most common)

Use when: choosing between options, designing a system, evaluating tradeoffs.

Step 1: deep_research (2-3 structured questions)
   - Use the full template (Section 5)
   - Attach relevant code files showing current architecture
   - Ask about tradeoffs, failure modes, and scaling concerns

Step 2: search_reddit (5-7 queries)
   - "[option A] vs [option B]" in relevant subreddits
   - "[option A] production experience"
   - "[option A] regret" or "switched from [option A]"
   - "best [category] for [your constraints]"

Step 3: get_reddit_post (5-7 best threads from Step 2)
   - use_llm=false to get raw opinions with exact reasoning
   - Look for dissenting comments and experience-based warnings

Step 4: web_search (3-5 queries for official sources)
   - Official benchmarks, documentation, migration guides
   - Site-targeted: site:docs.x.com, site:github.com/x

Step 5: scrape_links (3-5 authoritative URLs from Step 4)
   - Extract: "features | limitations | pricing | compatibility | migration path"

Total time: 5 tool calls. Covers: expert analysis, community validation, official docs.

Pattern C: Library / Dependency Research

Use when: evaluating a library, finding alternatives, checking maintenance health.

Step 1: web_search (5-7 queries)
   - "[lib A] vs [lib B] [year]"
   - "best [category] library [language] [year]"
   - "[lib] alternatives"
   - "[lib] benchmark" or "[lib] performance"
   - site:github.com "[lib]" stars

Step 2: search_reddit (5-7 queries)
   - "[lib] production experience" in language-specific subreddits
   - "[lib] problems" or "[lib] issues"
   - "switched from [lib]" or "migrated from [lib]"
   - "r/[language] [category] recommendation"

Step 3: scrape_links (3-5 URLs)
   - GitHub repos: extract "stars | last commit | open issues | contributors"
   - Package pages: extract "downloads | version | dependencies | size"
   - Doc sites: extract "features | API surface | examples | limitations"

Step 4: deep_research (1-2 questions)
   - Synthesize all findings into a recommendation with your constraints
   - Attach your code to get integration-specific advice

Total time: 4 tool calls. Covers: comparisons, community trust, maintenance health, fit.

4. The Category Router

Use this table to route the user's task to the correct reference file and tool sequence.

If the task involves...	Reference file	Primary tool flow
Runtime errors, compiler errors, crashes	`references/bug-fixing.md`	web_search -> scrape_links -> search_reddit
Library selection, migration, compatibility	`references/library-research.md`	web_search -> search_reddit -> scrape_links
System design, patterns, database choice	`references/architecture.md`	deep_research -> search_reddit -> get_reddit_post
Async, type systems, macros, FFI, idioms	`references/language-idioms.md`	web_search -> deep_research -> get_reddit_post
CI/CD, Docker, K8s, monitoring, infra	`references/devops.md`	web_search -> scrape_links -> search_reddit
OWASP, auth, encryption, input validation	`references/security.md`	deep_research -> scrape_links -> web_search
Profiling, query optimization, caching	`references/performance.md`	deep_research -> search_reddit -> scrape_links
Third-party APIs, webhooks, OAuth, payments	`references/api-integration.md`	web_search -> scrape_links -> deep_research
Test frameworks, mocking, E2E, load testing	`references/testing.md`	search_reddit -> deep_research -> web_search
Framework migration, SSR/SSG, accessibility	`references/frontend.md`	web_search -> search_reddit -> scrape_links

Category Use Cases

Bug Fixing (references/bug-fixing.md)

Decoding cryptic runtime errors and stack traces
Resolving dependency conflicts and version mismatches
Debugging memory leaks and resource exhaustion
Fixing race conditions and concurrency bugs
Handling deprecation warnings and breaking changes
Diagnosing environment-specific failures (CI vs local, OS-specific)
Fixing build and compilation errors
Debugging network and timeout issues
Resolving ORM and database driver errors
Handling encoding, locale, and timezone bugs

Library Research (references/library-research.md)

Evaluating competing libraries for the same task
Checking library maintenance health and bus factor
Planning major version migrations with breaking changes
Assessing bundle size impact for frontend dependencies
Verifying license compatibility for commercial projects
Finding libraries that meet specific compliance requirements
Comparing ORMs, HTTP clients, validators, and serializers
Evaluating framework plugin and extension ecosystems
Checking cross-platform and cross-runtime compatibility
Assessing community size and support quality

Architecture (references/architecture.md)

Choosing between monolith, microservices, and modular monolith
Selecting databases for specific access patterns
Designing event-driven and message-based systems
Planning CQRS and event sourcing implementations
Evaluating caching strategies and layers
Designing multi-tenant systems
Planning API versioning and evolution strategies
Choosing between REST, GraphQL, gRPC, and tRPC
Designing for horizontal scaling and sharding
Evaluating serverless vs container-based architectures

Language Idioms (references/language-idioms.md)

Understanding async patterns (promises, futures, goroutines, tokio)
Navigating advanced type system features (generics, traits, HKTs)
Using macros, metaprogramming, and code generation
FFI and cross-language interop patterns
Error handling idioms across languages
Concurrency primitives and memory models
Package and module system best practices
Language-specific performance patterns
Compiler/interpreter configuration and optimization flags
Understanding borrow checkers, lifetimes, and ownership

DevOps (references/devops.md)

Writing and debugging CI/CD pipelines (GitHub Actions, GitLab CI)
Optimizing Docker images and multi-stage builds
Configuring Kubernetes deployments, services, and ingress
Setting up monitoring, alerting, and observability (Prometheus, Grafana)
Managing infrastructure as code (Terraform, Pulumi, CDK)
Configuring reverse proxies and load balancers (nginx, Caddy, Traefik)
Managing secrets and environment configuration
Setting up log aggregation and structured logging
Planning deployment strategies (blue-green, canary, rolling)
Debugging DNS, networking, and certificate issues

Security (references/security.md)

Implementing authentication flows (OAuth2, OIDC, SAML, passkeys)
Preventing OWASP Top 10 vulnerabilities
Securing API endpoints and rate limiting
Implementing encryption at rest and in transit
Input validation and output encoding
Configuring CSP, CORS, and security headers
Managing secrets and credential rotation
Auditing dependencies for known vulnerabilities
Implementing RBAC and ABAC authorization models
Securing file uploads and user-generated content

Performance (references/performance.md)

Profiling CPU, memory, and I/O bottlenecks
Optimizing database queries and indexes
Implementing caching strategies (Redis, CDN, in-memory)
Reducing bundle size and improving frontend load times
Optimizing API response times and throughput
Diagnosing and fixing N+1 query problems
Connection pooling and resource management
Lazy loading, pagination, and streaming patterns
Memory leak detection and garbage collection tuning
Load testing and capacity planning

API Integration (references/api-integration.md)

Integrating payment processors (Stripe, PayPal, Square)
Setting up OAuth2 flows with third-party providers
Handling webhooks reliably (idempotency, retry, verification)
Working with rate-limited APIs (backoff, queuing, caching)
Integrating email services (SendGrid, SES, Postmark)
Working with cloud storage APIs (S3, GCS, Azure Blob)
Consuming GraphQL APIs from external services
Handling API versioning and deprecation from providers
Integrating search services (Algolia, Elasticsearch, Meilisearch)
Setting up real-time integrations (WebSockets, SSE, polling)

Testing (references/testing.md)

Choosing and configuring test frameworks
Writing effective unit tests with proper isolation
Mocking external services, databases, and APIs
Setting up E2E testing (Playwright, Cypress, Selenium)
Implementing contract testing for microservices
Load testing and stress testing (k6, Artillery, Locust)
Snapshot testing and visual regression testing
Testing async code, timers, and event-driven systems
Measuring and improving code coverage meaningfully
Setting up test databases and fixtures

Frontend (references/frontend.md)

Migrating between frontend frameworks or major versions
Choosing between SSR, SSG, and CSR strategies
Implementing accessibility (WCAG compliance, screen readers)
Optimizing Core Web Vitals (LCP, FID, CLS)
State management patterns and library selection
Responsive design, mobile-first, and cross-browser issues
Implementing design systems and component libraries
Handling forms, validation, and complex user inputs
Internationalization and localization (i18n/l10n)
Progressive web apps and offline-first patterns

5. Tool Best Practices

web_search

Minimum 3 queries, recommended 5-7. Each query MUST target a different angle.
Always quote exact error messages with "double quotes" to avoid partial matches.
Add the current year for fast-moving ecosystems: "Next.js middleware 2026".
Use site: for precision: site:github.com, site:stackoverflow.com, site:docs.rs.
Cover 7 angles: broad topic, specific technical term, problems/debugging, best practices, comparison (A vs B), tutorial/guide, advanced patterns.
NEVER stop at web_search. It returns URLs, not content. Always follow with scrape_links.
Use -exclude to filter noise: -site:pinterest.com -site:medium.com for technical queries.

search_reddit

Minimum 3 queries, recommended 5-7. Each query targets a different facet.
Target specific subreddits: Include r/rust, r/typescript, r/devops in queries.
Search for NEGATIVE signal: "regret", "switched from", "problems with", "don't use", "wish I had known". Negative experiences are more informative than praise.
Use intitle: for focused results: intitle:"postgres vs mysql" r/database.
Search for failure modes, not just success stories. "X broke in production" is gold.
Follow up with get_reddit_post on the 5-7 highest-signal threads.
Use date_after to filter for recent posts when technology changes rapidly.

get_reddit_post

Always set fetch_comments=true. Comments contain the best insights.
Default use_llm=false is correct for most cases. Raw comments preserve exact quotes, code snippets, version numbers, and config values that LLM summarization loses.
Only use use_llm=true when processing 20+ posts and the user explicitly wants synthesis.
Fetch 5-10 posts for broad consensus (balanced depth). Fetch 2-3 for deep dives (max depth).
Read dissenting comments. The second or third reply that disagrees with the top answer often contains crucial corrections, edge cases, or updated information.
Check comment timestamps. A top-voted answer from 3 years ago may be outdated.

deep_research

Always use the structured template. Without it, answers are shallow and generic:

WHAT I NEED: [clear goal]
WHY: [decision or problem context]
WHAT I KNOW: [current understanding — so research fills gaps, not basics]
HOW I'LL USE: [implementation, debugging, architecture]
SPECIFIC QUESTIONS: 1) ... 2) ... 3) ...
PRIORITY SOURCES: [optional — preferred docs/sites]
FOCUS: [optional — performance, security, simplicity]

Attach relevant code files. This is MANDATORY for bug, performance, and code review questions. Without attached code, deep_research gives generic textbook answers.
Use 2-5 parallel questions for comprehensive coverage. Each question should target a different facet of the problem.
State your constraints: tech stack, team size, timeline, compliance requirements.
2 questions = deep dive (16K tokens each). 5 questions = balanced. 10 = rapid scan.

scrape_links

Recommended 3-5 URLs for balanced depth (6-10K tokens per URL).
Use pipe-separated extraction targets. Be specific:
- Good: "pricing tiers | free tier limits | API rate limits | auth methods | SDKs"
- Bad: "extract all pricing information"
Default use_llm=true for structured extraction. It strips nav bars, ads, footers.
Set use_llm=false only when you need raw HTML for debugging layout or scraping issues.
3 URLs = deep extraction (10K each). 10 URLs = balanced. 50 = scan mode (640 each).
Pair with web_search results. The standard workflow is: web_search -> pick URLs -> scrape_links.

6. Anti-Patterns

These are the most common mistakes agents make during research. Avoid all of them.

Shallow Research (most common)

Using ONLY web_search and stopping. You have URLs but no content and no validation. Fix: Always follow web_search with scrape_links, and add search_reddit for validation.

Generic Deep Research

Using deep_research without attaching code files. The answers will be textbook-generic. Fix: Always attach the relevant source files with descriptions of what to focus on.

Single-Source Trust

Trusting a single Reddit comment or a single blog post as ground truth. Fix: Cross-validate with at least 2 sources. Check if the comment is recent and upvoted.

URL Hoarding

Running web_search and collecting 70 URLs but never scraping any of them. Fix: Pick the top 3-5 most relevant URLs and run scrape_links immediately.

Vague Questions

Asking deep_research a vague question like "How do I set up auth?" Fix: Use the structured template. Specify your stack, constraints, and specific questions.

Losing Exact Values

Using get_reddit_post with use_llm=true when you need exact config values or code. Fix: Keep use_llm=false (the default). Only use LLM synthesis for 20+ post overviews.

Positive-Only Search Bias

Searching only for "best X" and "X tutorial" while ignoring failure signals. Fix: Always include negative queries: "problems with X", "X regret", "switched from X".

Unverified Citations

Treating deep_research output as fully cited fact. It can hallucinate sources. Fix: When a claim matters, verify it by running web_search + scrape_links on the source.

Stale Information

Accepting answers without checking recency. A 2022 answer about a 2026 framework is risky. Fix: Add year to queries. Check date_after on Reddit. Verify against official changelogs.

Over-Researching

Running all 5 tools for a simple factual question that web_search + scrape_links answers. Fix: Match research depth to question complexity. Simple bug = Pattern A. Architecture = Pattern B.

Quick Start

If you are an agent reading this for the first time:

Identify the task category using the router table in Section 4.
Pick the workflow pattern (A, B, or C) from Section 3.
Open the reference file listed in Section 4 for detailed use-case guidance.
Follow the best practices in Section 5 for each tool you invoke.
Check yourself against the anti-patterns in Section 6 before finishing.

For any research task, the minimum viable workflow is: web_search (find URLs) -> scrape_links (get content) -> validate with one more tool.

Never ship research based on a single tool's output.

research-powerpack-guide