Skip to main content
command CX Codex

deep-dive — Claude Code command: research a topic with sources

deep-dive — a slash command that investigates a topic from several angles and writes a structured report into artifacts/research/ inside your project.

MIT ★ 1,988 updated 2026-04-01

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add glittercowboy/taches-cc-resources
/plugin install taches-cc-resources@taches-cc-resources
Open on GitHub

What deep-dive does

Give it a topic, or drop the argument and it picks up whatever you are working on. Before any research begins, the command asks two to four questions through AskUserQuestion: what you need to understand, how deep, which angle matters. A second prompt then offers three paths: start, ask more, or add context yourself.

The report follows one layout every time: summary, key questions, overview, mechanics, history, patterns, limitations and edge cases, current state, takeaways, open questions. A claude_context block at the end lists when to use the thing and when to avoid it, plus libraries, patterns, conflicts and alternatives. The result lands in artifacts/research/ as YYYY-MM-DD-[topic]-deep-dive.md and the command prints that path back.

The file goes into the working directory you ran it from. Because of the intake gate, this is not a one-line lookup tool: nothing gets researched until you answer.

What it helps with

  • understand how an unfamiliar tool actually works before adopting it
  • trace why a technology exists and what it replaced
  • list failure modes and edge cases up front
  • keep a dated research file with sources inside the repo
  • feed a decision with structured notes before /plan/project

Example prompts for the agent

  • /deep-dive Kubernetes networking: I need the mechanics and the usual mistakes
  • Run /deep-dive with no argument and investigate what we are working on right now
  • /deep-dive Compare Postgres and SQLite for a small CLI tool

How to install deep-dive

1Plugin marketplace

/plugin marketplace add glittercowboy/taches-cc-resources
/plugin install taches-cc-resources@taches-cc-resources

2Manually: put the files in place

.claude/commands/deep-dive.md

Call it with /deep-dive. For all projects use ~/.claude/commands/

Questions about deep-dive

How do I install deep-dive in Claude Code?

Add the marketplace: /plugin marketplace add glittercowboy/taches-cc-resources, then install the plugin: /plugin install taches-cc-resources@taches-cc-resources. The command file itself is .claude/commands/deep-dive.md.

What does deep-dive do?

It runs an investigation on the topic you name and puts the result in a single file: mechanics, history, patterns, limitations, takeaways. At the end it points to a next step, either applying the knowledge or running /plan/project.

Where does the report get saved?

Under artifacts/research/ in the current working directory. The filename combines the date, a slug of the topic and deep-dive.md, for example 2025-01-15-kubernetes-networking-deep-dive.md.

Source text

deep-dive.md · MIT
---
description: Comprehensive investigation of a topic - thorough analysis with sources
argument-hint: [topic or leave blank for current context]
---

<objective>
Conduct a deep-dive investigation into $ARGUMENTS (or the current topic if no arguments provided).

Go beyond surface-level understanding. Synthesize multiple sources into comprehensive knowledge.
</objective>

<intake_gate>

<context_analysis>
First, analyze $ARGUMENTS to extract what's already provided:
- The topic to investigate
- Specific questions to answer
- Depth required
- How this knowledge will be used

Only ask about genuine gaps - don't re-ask what's already stated.
</context_analysis>

<initial_questions>
Use AskUserQuestion to ask 2-4 questions based on actual gaps:

**If questions unclear:**
- "What do you need to understand?" with options: How it works, When to use it, Why it exists, Limitations/gotchas, All of the above, Other

**If depth unclear:**
- "How deep should I go?" with options: Overview (key points only), Solid understanding (main concepts), Comprehensive (thorough coverage), Other

**If focus unclear:**
- "Any specific angles?" with options: Practical application, Theoretical understanding, Comparison to alternatives, Historical context, Other

**If application unclear:**
- "How will this be used?" with options: Inform implementation, Make architecture decision, Evaluate feasibility, General knowledge, Other

Skip questions where $ARGUMENTS already provides the answer.
</initial_questions>

<decision_gate>
After receiving answers, use AskUserQuestion:

Question: "Ready to start the deep dive, or would you like me to ask more questions?"

Options:
1. **Start research** - I have enough context
2. **Ask more questions** - There are details to clarify
3. **Let me add context** - I want to provide additional information

If "Ask more questions" → generate 2-3 contextual follow-ups, then present decision gate again
If "Let me add context" → receive input, then present decision gate again
If "Start research" → proceed to research
</decision_gate>

</intake_gate>

<process>
After intake complete:

1. Define the scope and key questions to answer
2. Gather information from multiple angles:
   - How it works (mechanics)
   - Why it exists (history, motivation)
   - How it's used (patterns, best practices)
   - Where it fails (limitations, edge cases)
   - What's next (trends, evolution)
3. Synthesize into coherent understanding
4. Identify remaining unknowns
</process>

<output_format>
## Deep Dive: [Topic]

### Strategic Summary
[2-3 sentences: what this is, key insight, main implication for our work]

### Key Questions
- [Question this research answers]
- [Question this research answers]

### Overview
[2-3 paragraph synthesis of what this is and why it matters]

### How It Works
[Detailed explanation of mechanics, architecture, or process]

### History & Context
[Why it exists, what problem it solved, how it evolved]

### Patterns & Best Practices
- [Pattern/practice 1]: [when and why]
- [Pattern/practice 2]: [when and why]
- [Pattern/practice 3]: [when and why]

### Limitations & Edge Cases
- [Limitation]: [workaround or mitigation]
- [Edge case]: [how to handle]

### Current State & Trends
[Where things are heading, recent developments, community direction]

### Key Takeaways
1. [Most important insight]
2. [Second most important insight]
3. [Third most important insight]

### Remaining Unknowns
- [ ] [Question that still needs answering]
- [ ] [Question that still needs answering]

### Implementation Context
<claude_context>
<application>
- when_to_use: [situations where this applies]
- when_not_to_use: [situations to avoid this]
- prerequisites: [what must be true to use this]
</application>
<technical>
- libraries: [relevant packages/tools]
- patterns: [code patterns to follow]
- gotchas: [common mistakes, edge cases]
</technical>
<integration>
- works_with: [complementary technologies]
- conflicts_with: [incompatible approaches]
- alternatives: [other options to consider]
</integration>
</claude_context>

**Next Action:** Apply this knowledge to implementation, research specific aspect deeper, or run /plan/project

### Sources
- [Source name]: [URL] - [date accessed]
- [Source name]: [URL] - [date accessed]
</output_format>

<artifact_output>
Save the research to a file:

1. Create directory structure if it doesn't exist:
   - `[current-working-directory]/artifacts/research/`

2. Generate filename from topic:
   - Get current date in YYYY-MM-DD format
   - Slugify the topic (lowercase, hyphens for spaces)
   - Format: `YYYY-MM-DD-[topic]-deep-dive.md`
   - Example: `2025-01-15-kubernetes-networking-deep-dive.md`

3. Write the complete research to the file

4. Report to user: "Saved to `artifacts/research/[filename]`"
</artifact_output>

<success_criteria>
- Answers the key questions thoroughly
- Goes beyond surface-level (not just "what" but "why" and "when")
- Identifies limitations honestly
- Synthesizes into actionable understanding
- Implementation context is specific enough for Claude to apply
- Clear about what's still unknown
- Output saved to artifacts/research/ directory
</success_criteria>

© Lex Christopherson · MIT · glittercowboy/taches-cc-resources

Similar slash commands

All slash commands for Agent setup: memory, context, orchestration →
nansen-wallet-deep-dive nansen-ai The nansen-wallet-deep-dive skill runs a wallet through labels, balance, PnL, transactions, perp positions and counterparties via the Nansen CLI. Useful when you need to know who is behind an address. CX Codex +1 393installs user-deep-dive PostHog user-deep-dive turns an email address into a PostHog user profile: what the person does in the product and which reports they keep open. Handy before a customer call. CX Codex +1 212installs anthropic-technical-deep-dive curiositech anthropic-technical-deep-dive builds deep technical preparation for Anthropic interviews: Constitutional AI, RLHF, interpretability, scaling laws, MCP, agentic systems, and AI safety. CX Codex +1 141installs Redfin Property MCP — Single-Address Deep Dive nexgendata-apify Redfin Property MCP — Single-Address Deep Dive is an MCP server that searches Redfin listings by filters and retrieves a home's detailed history by address or URL. CX Codex +1 5,877installs keyword-deep-dive inhouseseo The keyword-deep-dive skill studies one keyword: reads the Google SERP, inspects the top three competitors and returns a 90-day ranking plan. Useful when you are deciding whether a query is worth chasing. CX Codex +1 ★ 416repo stars Animation Principles - Deep Dive dylantarre Animation Principles - Deep Dive — a reference skill covering Disney's 12 animation principles with technical detail: deformation ratios, frame counts, arcs, follow through. Useful when the agent needs animation context. CX Codex +1 560installs

From the same set48

The whole set →
run-plan run-plan executes a PLAN.md file directly without loading planner skill overhead. It routes tasks to subagents and keeps most of the context window free. CX Codex +1 ★ 1,988repo stars build-macos-apps build-macos-apps is a Claude Code skill for building native macOS apps with SwiftUI and AppKit. It routes work on new apps, bugs, tests, performance, and releases to a matching workflow. CX Codex +1 ★ 1,988repo stars options A command to evaluate multiple options side-by-side: tools, approaches, architectures. It asks clarifying questions, builds a comparison matrix, and recommends the best choice with reasoning. CX Codex +1 ★ 1,988repo stars competitive competitive researches competitors for any feature or product, maps market gaps, and saves a markdown report to your project. CX Codex +1 ★ 1,988repo stars history history — a command to research historical attempts at solving a task: what was tried before, what worked, what mistakes to avoid. Helps prevent repeating errors and apply lessons from experience. CX Codex +1 ★ 1,988repo stars technical Researches technical implementation options, evaluates libraries and tradeoffs, and saves a ready architecture brief into Markdown. CX Codex +1 ★ 1,988repo stars feasibility feasibility is a command that assesses whether a project can meet its constraints and recommends whether to proceed, revise terms, or stop. CX Codex +1 ★ 1,988repo stars landscape Maps a domain landscape: identifies key players, available tools, trends and gaps. Takes a domain name or works in current context without arguments. CX Codex +1 ★ 1,988repo stars

Project sponsors

Companies that keep this analytics open