home / skills / technickai / ai-coding-config / research

This skill helps you verify current API behavior and latest tooling before coding, saving debugging time and ensuring secure, future-proof implementations.

npx playbooks add skill technickai/ai-coding-config --skill research

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.5 KB
---
name: research
# prettier-ignore
description: "Use when current web info needed, verifying APIs still work, checking latest versions, or avoiding outdated implementations"
version: 1.2.0
category: research
triggers:
  - "research"
  - "look up"
  - "check current"
  - "verify API"
  - "is this still"
  - "latest version"
  - "deprecated"
---

<philosophy>
Research when getting it right matters. When current information saves hours of debugging, ensures secure implementations, or guides you to the right abstraction—research first.
</philosophy>

<natural-triggers>
Clear signals that research is needed:
- Hitting an error that smells like an API change
- Implementing something security-critical (auth, payments, file handling)
- Making architecture decisions you'll live with for months
- Working with libraries you know evolve rapidly
- That moment of "wait, is this still how we do this?"
</natural-triggers>

<quick-check>
When: Mid-flow verification
Time: Under a minute

Examples: "Is useEffect still the way to handle this in React 18?", "Did Stripe change
their webhook payload?", "What's the current Node LTS version?"

Just search, grab the answer, keep coding. No storage, no ceremony, no permission
needed. </quick-check>

<deep-dive>
When: The decision really matters
Time: 5-15 minutes

Examples: Choosing between competing technologies, understanding a new architectural
pattern, debugging something that doesn't match documentation.

Always ask first: "This needs deeper research (5-15 min). Should I dig into this now?"
Let the user decide if they want to pause for research or continue with existing
knowledge.

Research thoroughly, save findings in research/[topic].md for team reference.
</deep-dive>

<tool-selection>
Always use the best available web search. Priority order:

MCP servers (preferred when available):

- Tavily MCP server
- Exa MCP server
- Other specialized search MCP servers

Built-in tools (fallback):

- Cursor: web_search tool
- Claude Code: Built-in web search

Tell the user which you're using:

- "Using Tavily MCP server for enhanced search capabilities"
- "Using Exa MCP server for code-focused research"
- "Using built-in web search (no MCP servers configured)"

This transparency helps users understand tool selection and configure MCP servers if
desired. </tool-selection>

<search-strategy>
Start with official sources - docs, changelogs, GitHub releases. Then expand to community discussions if needed.
</search-strategy>

<output-format>
Output should be scannable and actionable. Skip the fluff, get to what matters.

Good pattern:

## Stripe Checkout v4 Migration

Breaking change: redirectToCheckout() removed in v4

New pattern:

- Use Payment Element (unified UI)
- Or Checkout Sessions API (hosted page)

Migration: [Specific code example]

Source: Stripe docs v2024.11.15 </output-format>

<key-principles>
Recognize patterns: When you see version-specific errors, deprecated methods, or post-2023 technologies, that signals research is needed.

Be transparent: Say "I should verify this" or "Let me check current best practices"
rather than guessing.

Speed over perfection: For quick checks, first good answer wins. For deep dives,
thoroughness matters.

No unnecessary storage: Quick research lives in the conversation. Only save deep
research that others might reference. </key-principles>

<common-pitfall>
Don't research everything. If your React knowledge from 2023 still works and the user isn't hitting issues, just build. Research is a tool, not a crutch.
</common-pitfall>

Overview

This skill helps you decide when to stop guessing and verify current web information. Use it to confirm API behaviors, check library versions, and avoid stale implementations that cost time or introduce security issues. I prioritize speed for quick checks and depth when decisions matter.

How this skill works

I inspect official sources first (docs, changelogs, GitHub releases), then expand to community discussions and examples. For searches I prefer MCP servers when available and will tell you which one I used (Tavily, Exa, or built-in web search). Quick checks return a concise answer; deep dives produce a short, referenced summary and recommended action.

When to use it

  • You get an error that looks like an API or breaking change
  • Implementing security-critical flows (auth, payments, uploads)
  • Choosing an architecture or dependency you’ll live with for months
  • Working with fast-moving libraries or post-2023 technologies
  • You pause and think: “Wait, is this still how we do this?”

Best practices

  • Start with official docs, changelogs, and releases before community sources
  • Declare search tool used (Tavily/Exa/built-in) so users can configure MCPs
  • Short checks: aim for one clear answer under a minute; deep dives: 5–15 minutes with sources
  • Ask user permission before spending 5–15 minutes on a deeper investigation
  • Save deep research summaries in a team-accessible file only when they add long-term value

Example use cases

  • Quickly verify if a React lifecycle or hook answer changed in React 18+
  • Check whether Stripe webhook payloads or endpoints changed before deploying payments code
  • Confirm current Node LTS version and recommended Docker base image
  • Compare pros/cons of two competing agent frameworks before committing
  • Debug an API that returns unexpected fields by checking recent changelogs and release notes

FAQ

Which search tool will you use?

I prefer MCP servers: Tavily first, then Exa, then other MCPs. If none are configured, I use built-in web search and I’ll tell you which one I used.

When should I allow a deep dive?

Allow deep dives when the decision affects security, long-term architecture, or debugging that blocks progress. I’ll ask before spending 5–15 minutes.

Do you store quick research results?

No. Quick checks live in the conversation. Only deep research meant for team reference is saved to a research file if you request it.