deep-interview_skill

Overview

This skill implements a Socratic, Ouroboros-inspired deep interview that transforms vague ideas into crystal-clear, testable specifications. It measures ambiguity across weighted dimensions, asks one targeted question at a time to expose hidden assumptions, and gates progress until ambiguity falls below a configurable threshold (default 20%). The finalized spec feeds into downstream planning and execution pipelines.

How this skill works

The agent parses the user’s idea, detects greenfield vs brownfield, and (for brownfield) maps the codebase before asking questions. Each round targets the weakest clarity dimension, scores all dimensions quantitatively, displays the ambiguity percentage, and updates persistent interview state. Challenge modes (Contrarian, Simplifier, Ontologist) activate at configured rounds to shift perspective. When the ambiguity threshold is met or the user exits, the agent crystallizes a spec file ready for planner/executor skills.

When to use it

• You have a vague idea and need rigorous requirements gathering before any build work.
• You want to prevent “that’s not what I meant” outcomes from autonomous execution.
• Task scope is unclear or complex enough that jumping straight to code wastes cycles.
• You require a mathematically-validated clarity gate before committing execution resources.
• You say things like “interview me”, “ask me everything”, or “don’t assume”.

Best practices

• Allow the agent to ask one question at a time and answer fully to improve scores efficiently.
• Provide references to existing files or repo locations for brownfield context to speed mapping.
• Accept the challenge modes — contrarian and simplifier questions often reveal critical assumptions.
• Use the early-exit option only when you accept remaining ambiguity and its tradeoffs.
• Run the recommended 3-stage pipeline (deep-interview → ralplan → autopilot) for highest quality.

Example use cases

• Turn a high-level product idea into a testable spec before hiring developers or starting execution.
• Clarify ambiguous feature requests that reference an existing codebase to avoid merge surprises.
• Reduce wasted autonomous runs by ensuring acceptance criteria and constraints are explicit.
• Prepare a specification for automated consensus planning and parallel implementation.
• Expose hidden assumptions in stakeholder requests before creating tasks or PRs.