Skip to content
Skills Library
Management & product · Planning

deep-interview

/deep-interview

Start a structured interview to gather requirements for complex features. Use when tackling multi-layer features, validating PRDs, or defining scope for implementation.

Licence
MIT
Last repository change
21.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Start a structured interview to gather requirements for complex features. Use when tackling multi-layer features, validating PRDs, or defining scope for implementation.

Arguments

/deep-interview <issue-number|prd-path|feature-description>
Original author description

Start a structured interview to gather requirements for complex features. Use when tackling multi-layer features, validating PRDs, or defining scope for implementation.

How it works

  1. Input
  2. Interview Process
  3. Output: PRD Generation
  4. Gotchas
Original SKILL.md headings · 135 lines, 605 words
SKILL.md preview
---
name: deep-interview
description: Start a structured interview to gather requirements for complex features. Use when tackling multi-layer features, validating PRDs, or defining scope for implementation.
argument-hint: "<issue-number|prd-path|feature-description>"
user-invocable: true
allowed-tools:
  - Bash(git:*)
  - Bash(gh:*)
  - Read
  - Glob
  - Grep
  - AskUserQuestion
  - Write
  - Agent
---

# Deep Interview

A structured interview process for gathering requirements and making design decisions on complex features.

## Input

`$ARGUMENTS` can be:

| Format              | Example                            | Description                    |
| ------------------- | ---------------------------------- | ------------------------------ |
| Issue number        | `#531` or `531`                    | GitHub issue to research first |
| PRD path            | `docs/feature-spec.md`             | Existing PRD to validate       |
| Feature description | `"user authentication flow"`       | Free-form description          |
| Nothing             | (empty)                            | Ask what we're planning        |

---

## Interview Process

### Phase 1: Context Gathering (Before Questions)

Silently research the topic before asking any questions:

1. If an issue number is provided, read the issue and its comments
2. Search for related documentation and existing code
3. Identify existing patterns that could be reused, and gaps between planned and current state

Summarize findings to the user before starting questions:
> "I've reviewed [issue/PRD/code]. Here's what I found: [current state, planned state, key gaps]. Let me ask some questions to clarify the approach..."

---

### Phase 2: Scope Definition

**First question — establish boundaries:**

```
Question: "What does [goal] mean to you? What's your target scope?"
Header: "Scope"
Options:
  - Minimal: [simplest version, automatic, no new UI]
  - Medium: [adds user interaction after completion]
  - Full: [mid-process interaction, complete workflow]
  - Other: (always available)
```

Options should represent increasing complexity, not different features.

---

### Phase 3: Approach Selection

**Second question — choose implementation strategy:**

```
Question: "Which approach do you prefer for [main mechanism]?"
Header: "Approach"
Options:
  - Option A: [simpler, faster to build]
  - Option B (Recommended): [better UX, more robust]
  - Hybrid: [combine best of both]
```

**Listen for:** If stakeholder suggests something different ("we could do X because Y already exists"), probe deeper — they have context about existing patterns.

---

### Phase 4: Priority Ranking

**Third question — identify most valuable improvements:**

```
Question: "What's the most valuable improvement for users right now?"
Header: "Priority"
multiSelect: true
Options:
  - [Capability A]: [benefit description]
  - [Capability B]: [benefit description]
  - [Capability C]: [benefit description]
```

---

### Phase 5: Implementation Details

Drill into specifics for each selected priority. Ask about context/data flow, UI/UX patterns, and behavior on triggers — adapting questions to the feature at hand.

---

### Phase 6: Technical Decisions

Architectural choices — new implementation vs reusing existing patterns, and why.

**Listen for:** "We could reuse X" — stakeholder knows about existing infrastructure you should leverage.

---

### Phase 7: Timeline & Scope Confirmation

Final questions: timeline expectation (quick win / full feature / polish) and any additional ideas or concerns.

---

## Output: PRD Generation

After completing the interview, generate a PRD covering:

- **Executive Summary** — what we're building and why
- **Design Decisions** — table of each decision, choice, and rationale
- **Architecture Overview** — current state and target state
- **Data Model Changes** — new and modified entities
- **API Changes** — new and modified endpoints
- **Frontend Changes** — new and modified components
- **Implementation Checklist** — phased tasks (foundation, core feature, polish)
- **Rollback Plan** — how to disable if issues arise
- **Open Questions** — unresolved items

Save the PRD to an appropriate location (e.g., `prds/[date]-[feature-name].md` or as specified).

---

## Gotchas

- Start broad (scope), then narrow (details) — never ask about timeline first
- Present tradeoffs, not just options. Mark recommended options with "(Recommended)"
- Don't present more than 4 options per question
- Probe when stakeholder mentions existing patterns — they have context you don't
- Summarize decisions before moving to next phase
- Use `multiSelect: true` when options aren't mutually exclusive

---

$ARGUMENTS

Versions

RepositoryScoreLicence
This page · propstreet/claude-powerpack100MIT
dlwlgus9125/ezpowers100MIT
jscraik/Agent-Skills100Apache-2.0
OXI-717/ai-native-toolkit100MIT
tranhieutt/software_development_department95MIT
zereight/gitlab-mcp90MIT
sean2077/skills85MIT

Database snapshot: 13.11.2026 · package version 18ace1346dd9 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90interview
    Conduct a structured interview about a feature or topic to gather requirements and produce a specification. This skill should be used when users want to think through a feature, clarify requirements, or create an implementation plan before coding.
  • 100create-prd
    Product Requirements Document (PRD) creation workflow. Use when defining implementation requirements for complex features, new subsystems, or any task affecting more than 10 files.
  • 100requirements-interview
    Conduct deep multi-round requirements interviews to produce executable SPEC, PRD, and PLAN drafts. Use when user says "clarify requirements", "采访需求", "extract requirements", "define scope", "analyze needs", or when requirements are ambiguous and need interactive clarification.…
  • 100writing-feature-prds
    Use when starting a new feature, defining requirements before implementation, or when the user says "new feature", "create a spec", "create a PRD", or "feature PRD".
  • 90implementation-workflow
    Use when turning PRDs or feature specs into actionable implementation workflows - provides structured task decomposition, dependency mapping, and validation gates.
  • 100prd
    Interview the user and write a Product Requirements Document at docs/PRD.md (or docs/prd/<name>.md for a feature) — problem, scope, user types, key flows, success criteria, risks. Use when the user wants to write a PRD, scope a product or feature, capture requirements or success…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.