This skill should be used when the user asks to "research the codebase", "understand how X works", "explore the code", "gather context", "investigate the implementation", "analyze the architecture", or invokes the rpikit:research command. Provides methodology for thorough interrogation and codebase exploration before planning or implementation.
/plugin marketplace add bostonaholic/rpikit/plugin install rpikit@rpikitThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Research topic: $ARGUMENTS
Help turn research requests into thorough codebase understanding through natural collaborative dialogue.
Start by understanding what the user needs to learn, then ask questions one at a time to refine the scope. Once you understand what you're researching, explore the codebase systematically, presenting findings in digestible sections and validating as you go.
Ask questions BEFORE exploring code.
Do not touch the codebase until the problem is understood. Resist the urge to immediately search for files or read code.
Your first action must be asking a clarifying question.
Do NOT:
Ask questions one at a time using AskUserQuestion:
Focus on understanding:
When you believe you understand, confirm:
Summarize your understanding and ask if it's accurate before proceeding. If anything needs clarification, ask follow-up questions.
Only proceed after confirming understanding with the user.
Use the file-finder agent to locate files relevant to the research objective:
Task tool with subagent_type: "file-finder"
Prompt: "Find files related to [topic from interrogation]. Goal: [user's stated purpose]"
The file-finder will return a structured report with:
Use TodoWrite to track exploration based on the file-finder report.
Examine core files first:
Trace relevant data flow:
Review supporting files:
Identify technical constraints:
If codebase exploration reveals external factors that need investigation, use the web-researcher agent:
Task tool with subagent_type: "web-researcher"
Prompt: "[specific research question about external topic]"
Use web research for:
The web-researcher returns findings with source citations and confidence assessments.
Present findings incrementally:
Create research document at: docs/plans/YYYY-MM-DD-<topic>-research.md
(Use today's date in YYYY-MM-DD format)
# Research: <Topic> (YYYY-MM-DD)
## Problem Statement
[What the user wants to accomplish]
## Requirements
[Key requirements gathered during interrogation]
## Findings
### Relevant Files
| File | Purpose | Key Lines |
| --------------- | ----------- | --------- |
| path/to/file.ts | Description | 42-87 |
### Existing Patterns
[Patterns discovered that inform implementation]
### Dependencies
[External and internal dependencies]
### External Research
[Findings from web research, if conducted - include sources]
### Technical Constraints
[Limitations discovered during exploration]
## Open Questions
[Questions that remain unanswered]
## Recommendations
[Initial thoughts on approach]
Ask what the user wants to do next:
Funnel questions - Start broad, narrow based on answers:
Assumption surfacing - Make assumptions explicit:
I'm assuming this needs to work with the existing auth system. Is that correct?
Trade-off questions - When multiple approaches exist:
There's a trade-off: Option A is faster to build but less flexible. Option B is more flexible but more complex. Which matters more here?
Clarification through examples - When requirements are vague:
Can you give me an example of what you'd expect to happen?
| Wrong | Right |
|---|---|
| Reading files immediately | Ask questions first |
| Multiple questions in one message | One question, wait, then next |
| "I understand, let me look" | "Let me confirm: [summary]. Accurate?" |
| "How should we handle this?" | "Should we A) do X, B) do Y, or C) something else?" |
| "I'll add a new AuthService" | "The codebase uses repository pattern. Auth is here." |
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.