# Deep Interview

> Socratic requirements gathering with ambiguity scoring. Use for clarifying vague ideas before building.

- Skill: `changhochien/deep-interview` (Agent Skill)
- Install (CLI): `npx skillmds@latest add changhochien/deep-interview`
- Raw SKILL.md: https://api.skillmd.com/api/skills/changhochien/deep-interview/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: changhochien (https://skillmd.com/u/changhochien)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/changhochien/deep-interview

---


# Deep Interview Skill

Socratic questioning to clarify requirements before execution.

## Usage

```
/skill:deep-interview "I want to build something cool"
/skill:deep-interview "help me understand what we need"
```

## Why This Exists

AI can build anything. The hard part is knowing WHAT to build.

Deep Interview ensures you have crystal-clear requirements before spending execution cycles.

## Scoring Dimensions

| Dimension | Weight | What it measures |
|-----------|--------|-----------------|
| Goal Clarity | 40% | Can you state the objective in one sentence? |
| Constraint Clarity | 30% | Are boundaries and limits clear? |
| Success Criteria | 30% | Can we write tests that verify success? |

## Ambiguity Formula

```
ambiguity = 1 - (goal × 0.4 + constraints × 0.3 + criteria × 0.3)
```

| Score | Meaning | Action |
|-------|---------|--------|
| 0-10% | Crystal clear | Proceed |
| 10-20% | Clear enough | Proceed (default threshold) |
| 20-40% | Some gaps | Continue questions |
| 40-60% | Significant gaps | Focus on weakest |
| 60-80% | Very unclear | May need reframing |
| 80-100% | Almost nothing known | Early stages |

## Process

### 1. Initialize

```json
{
  "active": true,
  "interview_id": "<uuid>",
  "initial_idea": "build something cool",
  "rounds": [],
  "current_ambiguity": 1.0,
  "threshold": 0.2
}
```

### 2. Ask One Question

Target the WEAKEST dimension:

```
Round 1 | Targeting: Goal Clarity | Ambiguity: 85%

"You mentioned wanting to build something cool. When you say this, 
what specific problem are you trying to solve? What does 'done' look like?"
```

### 3. Score After Answer

```
After Round 1:
- Goal Clarity: 0.4 (some understanding)
- Constraints: 0.2 (not discussed)
- Success Criteria: 0.1 (very vague)

Ambiguity: 1 - (0.4×0.4 + 0.2×0.3 + 0.1×0.3) = 73%
```

### 4. Report Progress

```
Round 1 complete.

| Dimension | Score | Weight | Weighted |
|-----------|-------|--------|----------|
| Goal | 0.4 | 0.4 | 0.16 |
| Constraints | 0.2 | 0.3 | 0.06 |
| Criteria | 0.1 | 0.3 | 0.03 |
| **Ambiguity** | | | **73%** |

Next target: Goal Clarity (lowest at 0.4)
```

### 5. Repeat Until ≤20%

- Ask one question per round
- Target weakest dimension
- Update scores
- Report progress

### 6. Generate Spec

When ambiguity ≤ threshold:

Create `.omp/specs/deep-interview-{slug}.md`:

```markdown
# Deep Interview Spec: Task Management App

**Interview ID:** abc123
**Rounds:** 5
**Final Ambiguity:** 18%
**Generated:** 2024-01-15

## Goal
A task management REST API that allows users to create, organize, and track tasks with deadlines.

## Constraints
- Must use PostgreSQL
- REST API with JSON responses
- JWT authentication required
- Must handle 1000 concurrent users

## Success Criteria
- [ ] User can create tasks with title, description, due_date
- [ ] User can list their tasks, filter by status
- [ ] User can mark tasks complete
- [ ] User can set task deadlines and get reminders
- [ ] API responds in < 200ms for 95th percentile

## Questions Asked
1. "What problem are you solving?" → User needs to track work tasks
2. "What technology constraints?" → Must use existing PostgreSQL stack
3. "How do we know it's working?" → API tests, user acceptance testing

## Interview Transcript
[Full Q&A rounds]
```

### 7. Bridge to Execution

```
Interview complete! Ambiguity: 18% (threshold: 20%)

How would you like to proceed?
1. /skill:plan "implement this spec" (Recommended)
2. /skill:autopilot "build this spec"
3. /skill:ralph "implement this spec"
4. Continue interviewing
```

## Question Templates

### Goal Clarity
- "What exactly happens when...?"
- "Who is the user, and what do they need?"
- "What's the core problem, not the solution?"

### Constraint Clarity
- "Are there technology constraints?"
- "What should this NOT do?"
- "Are there performance requirements?"

### Success Criteria
- "How do we know it's working?"
- "What would make you say 'yes, that's it'?"
- "What tests would verify success?"

## Challenge Questions (Round 4+)

Inject contrarian mode:

```
"You said this needs to support 10,000 users. What if it only 
needed 100? Would the architecture change?"
```

Inject simplifier mode:

```
"What's the simplest version that would still be valuable?"
```

## Limits

- **Soft limit:** 10 rounds (warn user)
- **Hard limit:** 20 rounds (proceed with warning)
- **Early exit:** User can exit at any time with warning