deep-dive

Run a 3-lane causal trace and deep-interview to crystallize requirements from evidence.

2|Updated May 11, 2026
One-click install
npx skills add https://github.com/xz1220/oh-my-kimi --skill deep-dive-xz1220
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deep-dive
Source: https://github.com/xz1220/oh-my-kimi/tree/main/skills/deep-dive
Command: npx skills add https://github.com/xz1220/oh-my-kimi --skill deep-dive-xz1220

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Deep-dive helps you investigate an unclear or evidence-heavy problem by first tracing the underlying causes and then turning the findings into a precise requirements specification instead of guessing.

Core Features & Use Cases

  • Two-phase pipeline: runs a 3-lane causal trace (parallel hypotheses) and then performs a focused deep-interview to crystallize what to do next.
  • 3-point injection: injects trace synthesis and lane-level critical unknowns into the interview so requirements building starts with evidence and uncertainty, not repetition.
  • Brownfield/greenfield handling: detects whether you’re working with existing codebases and adapts the approach accordingly, including codebase context reuse.
  • Evidence-structured outputs: produces both trace artifacts and a final spec containing a dedicated Trace Findings section.

Quick Start

Invoke deep-dive with your target problem statement, for example: /skill:deep-dive "Why does the production DAG fail intermittently on the transformation step?"

Frequently Asked Questions about deep-dive

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I conduct a root cause analysis for an intermittent production bug?

Root cause analysis for intermittent bugs requires tracing parallel hypotheses and synthesizing evidence. Deep-dive runs a 3-lane causal trace to investigate unclear system behaviors, injecting trace findings into an interactive interview to crystallize precise requirements.

Can I generate requirements specifications from an exploratory investigation of an existing codebase?

Yes, you can generate requirements specifications from exploratory investigations by detecting brownfield environments and reusing codebase context. The pipeline adapts its approach for existing codebases, turning causal trace findings into structured spec artifacts.

What is the best way to plan changes when system behavior is unclear and causal uncertainty is high?

The best way to plan changes with high causal uncertainty is running a parallel 3-lane causal trace to map hypotheses. Deep-dive conducts a focused deep-interview afterwards, using evidence-structured outputs to generate a final spec with dedicated trace findings.

How does multi-agent causal tracing work for bug diagnosis?

Multi-agent causal tracing for bug diagnosis works by running a parallel 3-lane pipeline to explore different hypotheses simultaneously. It requires interactive lane confirmation, persists state for resuming, and saves trace artifacts into deterministic paths for later review.

Does deep-dive work with Kimi CLI for interactive root cause investigation?

Yes, deep-dive works with Kimi CLI to guide root-cause investigation interactively. You invoke the skill with your target problem statement, and it separates data from instructions while injecting trace-derived context into the interview protocol.

When should I not use an interactive interview pipeline for requirements generation?

You should not use an interactive interview pipeline for requirements generation when the root cause is already clear or causal uncertainty is low. Deep-dive is specifically designed for evidence-heavy problems where underlying causes need parallel hypothesis tracing before spec generation.