deep-dive

Run causal trace lanes and evidence-grounded interviews to generate requirements specs.

Updated May 18, 2026
One-click install
npx skills add https://github.com/solitude6060/Yao-skills --skill deep-dive-solitude6060
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deep-dive
Source: https://github.com/solitude6060/Yao-skills/tree/main/skills/deep-dive
Command: npx skills add https://github.com/solitude6060/Yao-skills --skill deep-dive-solitude6060

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Deep-dive turns ambiguous problems into evidence-backed requirements by running a structured root-cause trace and then conducting a requirements interview grounded in that trace.

Core Features & Use Cases

  • 2-stage causal-to-requirements pipeline: performs evidence-driven trace lanes first (WHY), then runs a targeted interview to define actions precisely (WHAT).
  • 3 parallel trace lanes with confirmation: proposes and confirms three distinct causal hypotheses (implementation, config/orchestration, and measurement/artifact mismatch) before tracing.
  • 3-point trace injection into the interview: enriches initialization, replaces brownfield exploration with trace-derived system context, and seeds the first interview questions from per-lane unknowns.
  • Spec-ready handoff: generates a deep-interview standard spec with an added Trace Findings section and then bridges to execution orchestration.

Quick Start

Use deep-dive for an ambiguous bug or improvement request by running it with your problem statement so it investigates cause and produces a requirements spec.

Frequently Asked Questions about deep-dive

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

FAQPage Schema
How do I perform root cause analysis on an ambiguous incident before writing requirements?

Root cause analysis for ambiguous incidents requires a structured trace-then-interview pipeline. This Skill resolves unclear causes by running evidence-driven causal trace lanes first, then conducting a targeted interview to define actions precisely and generate a requirements specification.

What is the best way to investigate bugs in a brownfield codebase with missing requirements?

Investigating bugs in a brownfield codebase involves replacing manual exploration with trace-derived system context. The Skill proposes three parallel causal hypotheses—implementation, config orchestration, and measurement mismatch—then confirms one lane before tracing the actual issue.

Can I use causal investigation to triage workflow routing failures?

Yes, causal investigation can triage workflow routing failures by applying a three-lane hypothesis ranking mechanism. It isolates the confirmed failure lane from implementation, orchestration, and artifact mismatch perspectives before generating a final specification.

How does the trace-to-interview injection work for feature exploration?

Trace-to-interview injection enriches feature exploration by seeding the interview initialization with trace findings, replacing brownfield exploration with system context, and formulating the first interview questions from per-lane unknowns to ground the requirements.

Does deep-dive generate a requirements specification after causal tracing?

Yes, deep-dive generates a requirements specification after causal tracing. It produces a deep-interview standard spec that includes a dedicated Trace Findings section and then bridges directly to execution orchestration for the confirmed actions.

When should I not use a two-phase trace-then-interview approach for incident triage?

You should avoid a two-phase trace-then-interview approach when the incident cause is already explicitly known or when the problem lacks sufficient system artifacts for evidence-grounded tracing. It is designed specifically for ambiguous problems requiring deep investigation.