Skip to main content
skill CX Codex

deep-dive · rohitg00 — Claude Code skill: what it does, how to install

deep-dive runs multi-step deep research in Claude Code using DAG query planning, parallel subagents, and gap iteration without external APIs.

Apache-2.0 ★ 2,858 updated 2026-05-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rohitg00/awesome-claude-code-toolkit --skill deep-dive -a claude-code
Open on GitHub

What deep-dive does

The skill breaks an inquiry into a directed acyclic graph (DAG) of 4 to 8 targeted sub-questions. Independent questions launch concurrently as subagents using WebSearch with up to three searches per question. Claude tracks progress through TaskCreate jobs. It appends every source to /tmp/deep-dive-sources-[topic-slug].json so citations survive context compaction.

Once dependency waves finish, the skill runs at most one round of gap iteration for critical missing details. The completed synthesis turns findings into a structured report rather than a raw dump of agent outputs. Because files save into docs/deep-dive/ inside your project root, executing it inside a writable repository workspace is mandatory.

What it helps with

  • decompose ambiguous research questions into dependency-ordered sub-tasks
  • run concurrent web searches across parallel subagents
  • detect contradictions and missing context within a single follow-up wave
  • compile sourced analytical reports directly into project documentation

Example prompts for the agent

  • Run deep-dive on the trade-offs of using SQLite for high-throughput microservices
  • Deep-dive into current best practices for Model Context Protocol server security
  • Research the history and current landscape of DAG-based agent frameworks with deep-dive

How to install deep-dive

1Skills CLI (Vercel)

npx skills add rohitg00/awesome-claude-code-toolkit --skill deep-dive -a claude-code

2Manually: put the files in place

~/.claude/skills/deep-dive/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/deep-dive/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about deep-dive

How do I install deep-dive in Claude Code?

Run npx skills add rohitg00/awesome-claude-code-toolkit --skill deep-dive -a claude-code in your terminal or place the file into ~/.claude/skills/deep-dive/SKILL.md.

Does deep-dive require third-party search APIs?

No external API keys are needed. The workflow relies directly on Claude Code native subagents and the built-in WebSearch tool.

Where is the research output saved?

It writes a dated Markdown report into docs/deep-dive/ within your current project root.

Source text

SKILL.md · Apache-2.0
---
name: deep-dive
description: Claude-native deep research using DAG-based query planning, parallel subagent execution, and gap-driven iteration. No external API needed.
user-invocable: true
argument: The research question or topic to investigate deeply
---

# Deep Dive

Autonomous deep research using the same DAG-based planning pattern as Google's Deep Research — but running entirely on Claude Code with no external dependencies.

## How it works

1. **Plan** — decompose the question into a DAG of sub-questions with dependencies
2. **Fan out** — run independent sub-questions in parallel via Agent subagents
3. **Gap analysis** — each subagent returns findings + identified gaps
4. **Iterate** — gaps become new sub-questions, fed back into the DAG
5. **Synthesize** — once all nodes complete, produce a final report

## Steps

### 1. Decompose into a DAG

Given the research question, generate a DAG of sub-questions. Each node has:
- **id**: short identifier (e.g., `q1`, `q2a`)
- **question**: the specific sub-question to research
- **depends_on**: list of node IDs whose answers are needed first (empty = no dependencies)

**Rules for decomposition:**
- Start with foundational/context-setting questions that have no dependencies
- Build toward analytical/comparative questions that depend on foundational answers
- Aim for 4-8 nodes. If the topic needs more, cap at 12.
- Each node should be answerable with 1-3 web searches
- Questions should be specific enough that a researcher with no other context can answer them

**Print the DAG** as a table so the first brain can see the plan, then immediately proceed to execution — do not wait for confirmation.

**Create a task for each DAG node** using TaskCreate (description: the sub-question, status: pending). Also create tasks for "Gap analysis" and "Synthesize report". Update each task to `in_progress` when its wave launches and `completed` when the subagent returns. This gives the first brain real-time visibility into progress.

```
| ID | Question | Depends on |
|----|----------|------------|
| q1 | ...      | —          |
| q2 | ...      | —          |
| q3 | ...      | q1         |
| q4 | ...      | q1, q2     |
```

### 2. Execute in dependency order

Process the DAG in topological order:

**Wave 1:** Mark all Wave 1 node tasks as `in_progress`. Launch all nodes with no dependencies as **parallel Agent subagents**. As each subagent returns, mark its task `completed`. Each subagent gets this prompt:

```
You are a focused researcher. Answer this ONE question using web search:

Question: [the sub-question]

Instructions:
- Use WebSearch to find current, authoritative information
- Use 1-3 searches maximum
- Be specific and cite what you find

Return your answer in this exact format:

## Findings
[Your answer with specific facts, dates, numbers. Cite sources inline.]

## Gaps
[List anything you couldn't fully answer, contradictions you found, or
follow-up questions that would strengthen the answer. If none, say "None."]

## Sources
[List each source as: Title — URL]
```

**Citation persistence:** After each wave completes, append all sources from that wave to a file at `/tmp/deep-dive-sources-[topic-slug].json` as an array of `{"node_id", "title", "url"}` objects. This survives context compaction — if subagent results get compressed out of context, the sources file remains the source of truth. Read this file during synthesis to build the final Sources section.

**Wave 2+:** Once Wave 1 completes, mark all Wave 2+ node tasks as `in_progress` and launch nodes whose dependencies are now satisfied. Mark each task `completed` as its subagent returns. Include the findings from dependency nodes in the subagent prompt:

```
You are a focused researcher. Answer this ONE question using web search:

Question: [the sub-question]

Context from prior research:
[Paste findings from dependency nodes]

[same instructions as above]
```

Continue until all nodes complete.

### 3. Gap iteration (max 1 round)

Mark the "Gap analysis" task as `in_progress`. After all nodes complete, review the collected gaps across all subagents:
- If gaps are minor or don't affect the final answer: skip, move to synthesis
- If any gap is significant enough to change the conclusion: create 1-3 new targeted sub-questions and run them as a final parallel wave

Only do ONE gap iteration round. This is not an infinite loop.

Mark the "Gap analysis" task as `completed` when done (whether gaps were found or skipped).

### 4. Synthesize

Mark the "Synthesize report" task as `in_progress`. Combine all findings into a final report. Mark it `completed` when the report file is written. Structure:

```markdown
## Deep Dive: [Topic]

### Executive Summary
[3-5 sentences: the key takeaway]

### Findings

#### [Theme/Section 1]
[Synthesized findings from relevant nodes, not just copy-paste]

#### [Theme/Section 2]
[...]

### Open Questions
[Anything that couldn't be resolved — be honest about what's still unclear]

### Sources
[Deduplicated list of all sources from all subagents]
```

## Rules

- **Always show the DAG plan first.** Print it, then immediately start researching — no confirmation needed.
- **Parallel where possible.** Independent questions should always run as concurrent subagents.
- **One gap round max.** Don't spiral into infinite research loops.
- **Synthesize, don't concatenate.** The final report should read as a coherent document, not a list of subagent outputs stapled together.
- **Be honest about confidence.** If the research didn't produce clear answers, say so. Don't fill gaps with speculation.
- **Always persist the final report.** After synthesis, save the report as a markdown file in the appropriate project's `docs/deep-dive/` directory (create it if needed). Determine the project root from the current working directory or the context of the research request. Use a slugified topic name with date as the filename (e.g., `2026-04-02-jira-docs-from-microservices.md`). Never write final reports only to `/tmp` — they must land in a durable location within the relevant project.

© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit

Similar skills

All skills for Science and research →

deep-dive by other authors comes first.

deep-dive akillness deep-dive — a two-stage skill: three parallel lanes trace why something broke, then a requirements interview starts from those findings. Built for bugs and changes in code you don't know yet. CX Codex +1 177installs deep-dive ZaxbyHub deep-dive audits a selected part of a codebase without editing source files. Use it to investigate several aspects of a project and review evidence-backed findings. CX Codex +1 ★ 539repo stars deep-research akillness deep-research turns a topic into an extendable outline, sends parallel agents through each item, then writes a markdown report. Built for comparing a set of things across shared fields. CX Codex +1 120installs 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 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 set178

The whole set →
growth-engineer growth-engineer — a subagent for building analytics infrastructure: A/B testing with deterministic user assignment, funnel tracking, sample size calculation, and experiment monitoring with real-time guardrail checks. CX Codex ★ 2,858repo stars security-hardening security-hardening is a Claude Code skill for application security, covering input handling, authentication, secrets, and dependency checks. It applies to requests to review or strengthen a project’s security. CX Codex +1 ★ 2,858repo stars customer-success customer-success — a subagent for designing support systems: ticket triage, knowledge bases, workflow automation, and customer health scoring. CX Codex ★ 2,858repo stars marketing-analyst marketing-analyst — a subagent that builds your marketing data infrastructure: multi-touch attribution, ROI by channel, customer acquisition cost, and lifetime value forecasting. Turns marketing decisions from guesswork into data. CX Codex ★ 2,858repo stars patent-analyst patent-analyst — a Claude Code subagent that searches patent databases, analyzes prior art, maps IP landscapes, and assesses freedom to operate for technology products. CX Codex ★ 2,858repo stars workflow-director workflow-director — a subagent for Claude Code that orchestrates multi-step development workflows from start to finish with checkpoints and error recovery. CX Codex ★ 2,858repo stars llm-integration The llm-integration skill for Claude Code provides TypeScript patterns for Anthropic API integrations, including streaming, tool use, RAG, and token cost control. CX Codex +1 ★ 2,858repo stars security-researcher The security-researcher subagent investigates CVEs, maps attack surfaces, and models threats. Ask it to review project dependencies or draft actionable security findings. CX Codex ★ 2,858repo stars

Project sponsors

Companies that keep this analytics open