# Socialpranker/deepdive: a 13-phase research skill for Claude Code

> Deepdive is a Claude Code skill that turns a research request into a documented pipeline: a plan you approve before any search runs, parallel sub-agent search, per-claim source files, and an adversarial review pass. It is for people who need a folder they can reopen in a month, not a chat transcript.

**Socialpranker/deepdive** — Deepdive skill for Claude Code — 12-phase research pipeline: plan-review gate, parallel sub-agent search, claims-ledger triangulation with dissent protection, relevance × authority evidence filter, multi-angle red team, four-layer citation verification. 105 blocks, 29 channels, 460+ stat sources, 47 APIs, 1072 verified endpoints.

- Repository: https://github.com/Socialpranker/deepdive
- Website: https://socialpranker.github.io/deepdive/
- Stars: 375 · Forks: 3
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/socialpranker-deepdive

## The problem deepdive solves: research that leaves no trace

A normal LLM research session produces a wall of text. The sources sit somewhere in the chat history, the reasoning behind each choice is gone, and a month later nobody can reconstruct why one option was preferred over another. Deepdive attacks that specific loss. The README frames the contrast plainly: without it you get a one-shot prompt and lost sources, with it you get a plan.md that documents every choice and a source file per reference.

The audience is narrow and worth naming. This is a Claude Code skill, so the primary user already works in a Claude Code session and is willing to run a multi-phase job rather than a single prompt. The secondary audience is anyone willing to load SKILL.md and references/*.md into another model's context by hand, accepting that the sub-agent parts will not carry over. If you want a hosted research product with a web interface, this is not that.

## How the pipeline works, phase by phase

The README describes 13 phases run in order. Phase 1 reframes the question and a router classifies its profile as factual, multi-step, relational, comparative or landscape. That classification is not cosmetic: it selects the decomposition method. Factual questions get flat independent subquestions, multi-step ones such as "X given Y" get least-to-most leveling, and comparative ones get a shared axis matrix with mandatory opposition queries per candidate. The README is explicit that picking the wrong decomposition for a question's shape is a silent failure mode, which is the argument for making the router's choice visible.

Phase 3.7 is the plan-review gate, and it is the design decision the project leans on hardest. Before any search fires, you see the reframing, hypotheses, genre and channels, and you can approve or edit them. Strictness scales with mode: deep waits for an explicit go-ahead, medium is a soft check, shallow skips the gate. Phase 4 is a bounded search loop rather than a single pass, with three safeguards. A cheap goal-check tags each subquestion met, partial or unmet with a one-line reason. A no-progress circuit breaker stops the loop after two consecutive rounds that add nothing new to the source pool, regardless of remaining budget, and the unresolved thread moves to Open Questions. Phase 5 builds a claims ledger and triangulates, phase 5.5 filters evidence by relevance and authority, phase 6 synthesizes and runs a multi-angle red team, phase 6.5 verifies, and phase 8 walks through the decision forks and logs the outcome to application.md.

Model routing is part of the mechanism, not an implementation detail. Opus handles phases 1, 3 and 6 where reasoning compounds, Haiku handles the parallel fan-out in phase 4, and the skill announces the routing and an estimated cost up front, once. The repository also ships phases.yaml alongside the README's generated phase table, and the two disagree in the current revision: the README table lists 13 entries including 3.5 Capability Discovery, 3.7 Plan-review gate, 5.5 Evidence filter and 5.7 Wiki reconcile, while the description line says 12-phase. Check phases.yaml before you build anything on a specific phase number.

## Installing deepdive and running a first investigation

The README gives a single clone command for Claude Code. The path matters: the skill has to land in ~/.claude/skills/deepdive for Claude Code to pick it up.

```bash
# Clone
# (from the README)
git clone https://github.com/Socialpranker/deepdive.git \
  ~/.claude/skills/deepdive
```

After that, the README says you invoke it by typing a plain request in a Claude Code session, for example "Investigate X" or "Validate this hypothesis". The README's own worked example uses a comparison question about Postgres logical replication and CDC tooling. You should see the skill announce its model routing and estimated cost once, then produce a plan.md before any search runs. That plan is the gate: approve or edit it, and only then does phase 4 dispatch sub-agents.

For Claude Desktop with Skills enabled, the README packages the repository as a .skill bundle and uploads it through Settings, Skills, Add Skill.

```bash
# Package as .skill bundle
zip -r ../deepdive.skill . -x ".*" -x "*.zip"
```

For other models the README offers no installer at all. It says to load SKILL.md plus references/*.md into the context manually, skip the sub-agent parts, and use separate chat sessions per subtopic. That is a methodology transplant, not an install, and it loses the parallel search that most of the cost model is built around.

## Where deepdive breaks down

The plan-review gate is the strongest part of the design and also the most expensive to get wrong in the other direction. A deep-mode run blocks on an explicit go-ahead before any search fires. If you walk away from a session, the pipeline sits there. If you rubber-stamp the plan without reading the reframing and the channel list, you have paid the cost of the gate and kept none of the benefit, because the README's own position is that a wrong plan executed perfectly still produces a wrong report.

The no-progress circuit breaker is deliberately blunt. Two consecutive rounds that add nothing new to the source pool stop the loop and push the thread into Open Questions. That is the right default against token burn, but it means a topic where the useful sources appear late, after two thin rounds, gets cut off by a heuristic rather than by budget exhaustion. The README does not document an override for the breaker.

The sub-agent fan-out is the other boundary. It is a Claude Code capability. The README's own guidance for Codex, Gemini and local models is to skip those parts and run separate sessions per subtopic, which removes the parallelism and the shared source pool that phases 5 and 5.5 depend on. If your workflow is not Claude Code, you are reading deepdive as a methodology document, not running it as a tool. Finally, the project publishes no releases, so there is no versioned artifact to pin; you are tracking the main branch.

## How deepdive differs from a general deep-research assistant

A hosted deep-research assistant such as Gemini Deep Research and a skill like deepdive both accept a question and return a synthesized report, but they place the human at different points. The hosted assistant runs the search and hands you the result. Deepdive stops before the search and asks you to approve a plan, then stops again at phase 8 to walk through the decision forks and log what you picked to application.md. The README quotes Gemini Deep Research calling plan review its "biggest lever over output quality", which is a fair summary of the shared premise and also the clearest statement of where the two diverge in practice: one productized the lever, the other made it a blocking gate in your terminal.

The second difference is the artifact. A hosted report is a document. Deepdive's output is a folder: a 17-section plan.md, a sources directory where each source is a file with verbatim quotes, and atomic theses in findings/FN.md that the README describes as reusable. If your need is a shareable answer, the hosted tool is less friction. If your need is an audit trail you can reopen and extend, the folder is the point.

## Maintenance, licence and the cost of upgrading

The repository is not archived and the last push was on 2026-09-06, so it is being touched, but there are no retrieved releases, which means no tagged versions and no changelog to read before you pull. Upgrading is a git pull into ~/.claude/skills/deepdive, and because the skill is Markdown plus a phases.yaml, the upgrade cost is mostly re-reading the plan-review behaviour and the phase table rather than resolving code conflicts. The README's phase table is generated from phases.yaml between gen markers, so a pull can change the table without changing any prose around it.

The licence is MIT, which permits commercial and private use with the copyright notice retained. That is a statement about the repository's licence file, not legal advice, and if you redistribute the skill inside a product you should read LICENSE yourself. The README also advertises auto-validated APIs on a weekly workflow, but the README does not document what happens to a saved source when a referenced endpoint disappears, so treat catalog freshness as unverified.

## Conclusion

Adopt deepdive if you repeatedly research the same class of question and need the reasoning written down, not just the answer. Skip it if you want a one-shot answer or you are not working inside Claude Code, because the sub-agent fan-out has no equivalent path elsewhere. Before committing, read phases.yaml and the phase table in README.md together and check that the phase names still line up, since the two disagree in the current revision.

## FAQ

### How do I install deepdive for Claude Code?

Clone the repository into ~/.claude/skills/deepdive, which is the path the README gives. After that you invoke it by typing a request such as "Investigate X" in a Claude Code session.

### How do I use deepdive on a research question?

Type a request in a Claude Code session and the skill runs its phases in order, starting with reframing and ending with a decision walkthrough. Before any search fires, phase 3.7 shows you the reframing, hypotheses, genre and channels so you can approve or edit them.

### Does deepdive work outside Claude Code?

Only as a methodology. The README says to load SKILL.md and references/*.md into another model's context manually, skip the sub-agent parts, and use separate chat sessions per subtopic.

### What is deepdive?

It is a Claude Code skill that the README describes as a structured meta-research pipeline with hypothesis testing, parallel sub-agent search, source triangulation and adversarial review. Its output is a folder containing a plan document and one file per source.

## Sources

- [Issues](https://github.com/Socialpranker/deepdive/issues)
- [License: MIT](https://github.com/Socialpranker/deepdive/blob/main/LICENSE)
- [Project website](https://socialpranker.github.io/deepdive/)
- [README](https://github.com/Socialpranker/deepdive/blob/main/README.md)
- [Socialpranker/deepdive on GitHub](https://github.com/Socialpranker/deepdive)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/socialpranker-deepdive