deep-interview

Run a Socratic interview to convert vague requirements into explicit specifications.

Updated Apr 17, 2026
One-click install
npx skills add https://github.com/dropsyoon/oh-my-claudecode --skill deep-interview-dropsyoon
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deep-interview
Source: https://github.com/dropsyoon/oh-my-claudecode/tree/main/skills/deep-interview
Command: npx skills add https://github.com/dropsyoon/oh-my-claudecode --skill deep-interview-dropsyoon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents the system from executing on vague or underspecified ideas by turning uncertainty into explicit, testable requirements before any build or code changes happen.

Core Features & Use Cases

  • Socratic deep questioning that asks one question at a time to expose hidden assumptions and unstable scope.
  • Mathematical ambiguity gating that scores goal, constraints, and success criteria and refuses to proceed until ambiguity drops to an acceptable threshold.
  • Brownfield-safe context checks that gathers repo facts first (via exploration) and then confirms how the feature should fit, reducing “wrong integration” outcomes.
  • Use case: You say you want “a smarter interview assistant” and need it to behave consistently; deep-interview turns that into a concrete specification with clear non-goals and measurable acceptance criteria.

Quick Start

Use the deep-interview skill to interview your vague idea until it becomes a build-ready spec, then proceed with planning and execution.

Frequently Asked Questions about deep-interview

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

FAQPage Schema
How do I convert vague requirements into clear specifications before autonomous execution?

To convert vague requirements into clear specifications before autonomous execution, run a Socratic one-question-at-a-time interview with explicit ambiguity scoring. This exposes hidden assumptions and unstable scope, refusing to proceed until clarity thresholds are met.

What is ambiguity scoring in requirements gathering and how does it prevent building the wrong thing?

Ambiguity scoring in requirements gathering mathematically evaluates goals, constraints, and success criteria to prevent building the wrong thing. It gates autonomous execution by refusing to proceed until computed ambiguity from weighted clarity dimensions drops to an acceptable threshold.

How do I gather repository facts for brownfield integration before writing a feature specification?

To gather repository facts for brownfield integration before writing a feature specification, perform brownfield-safe context checks via repo exploration. This confirms how the feature should fit the existing codebase, reducing wrong integration outcomes before downstream pipeline stages.

Can I use Socratic questioning to gate autonomous execution for greenfield tasks with unclear success metrics?

Yes, you can use Socratic questioning to gate autonomous execution for greenfield tasks with unclear success metrics. It applies to both greenfield and brownfield tasks, asking one question at a time to expose hidden assumptions and compute a readiness-gating ambiguity score.

What is the best way to define non-goals and measurable acceptance criteria from a vague idea?

The best way to define non-goals and measurable acceptance criteria from a vague idea is to run a Socratic deep interview that persists state and outputs a spec. It turns uncertainty into explicit, testable requirements with clear non-goals for downstream pipeline stages.

When should I not use an autonomous agent for requirements gathering?

You should not use an autonomous agent for requirements gathering when your task lacks hidden assumptions or unstable scope, or when your goal, constraints, and success metrics are already explicit. In these cases, Socratic questioning and ambiguity scoring add unnecessary overhead.