Skip to content
Skills Library
Management & product · Planning

deep-interview

/deep-interview

Use when a vague task needs a clarification interview and structured brief. Triggers — "clarify task", "define requirements".

Licence
MIT
Last repository change
07.10.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
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.10.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

Use when a vague task needs a clarification interview and structured brief. Triggers — "clarify task", "define requirements".

Triggers from the description

clarify taskdefine requirements
Original author description

Use when a vague task needs a clarification interview and structured brief. Triggers — "clarify task", "define requirements".

How it works

  1. When to use
  2. When NOT to use
  3. Process
  4. Example Session
  5. Anti-patterns
Original SKILL.md headings · 162 lines, 780 words
SKILL.md preview
---
name: deep-interview
description: Use when a vague task needs a clarification interview and structured brief. Triggers — "clarify task", "define requirements".
---

# Deep Interview — Task Clarification

Clarify a vague task through focused one-at-a-time questions, then produce a structured brief.

**Input:** $ARGUMENTS

## When to use

- Task is too vague for brainstorming ("make it better", "fix the architecture", "add notifications")
- Scope is unclear — could be 1 hour or 1 week
- Multiple interpretations possible
- User hasn't thought through non-goals or constraints yet

## When NOT to use

- Task is already clear (specific file, specific bug, specific feature)
- User provided a spec or detailed description
- Already in brainstorming/planning phase

---

## Process

### Phase 1: Context Scan (silent, no output to user)

Before asking any questions:

1. For the project root and every directory scoped to the task, discover and read each applicable `AGENTS.md`; where a scope has no `AGENTS.md`, read its `CLAUDE.md` fallback. Recursively read the relative files referenced by `@` imports in each manifest or imported rule before proceeding.
2. Check git log for recent work context (last 10 commits)
3. Scan project structure (top-level dirs, key config files)
4. If task mentions specific areas — read those files

This gives you context to ask **informed** questions, not generic ones.

### Phase 2: Interview (interactive)

**RULES:**
- Ask **ONE question at a time**. Never dump multiple questions.
- Wait for answer before asking next question.
- Questions must be **specific and actionable**, not philosophical.
- Use context from Phase 1 to ask informed questions (reference files, patterns, existing code).
- Skip questions whose answers are obvious from the codebase.
- Maximum **7 questions** total. Stop earlier if picture is clear.
- After each answer, briefly acknowledge and move to next question.

**Question flow** (adapt order based on responses, skip what's already clear):

#### 1. Intent
"What's the end result you want? Not how — what should be different when this is done?"

#### 2. Trigger
"What prompted this? A bug, a user request, technical debt, new requirement?"

#### 3. Scope boundary
"What's IN scope and what's explicitly OUT? For example: [give 1-2 concrete examples based on codebase context]"

#### 4. Users / consumers
"Who uses this? End users, other developers, CI/CD, another service?"

#### 5. Constraints
"Any hard constraints? Timeline, compatibility, performance, specific tech stack, must not break X?"

#### 6. Success criteria
"How will you know this is done? What's the minimum that makes it shippable?"

#### 7. Known unknowns
"Anything you're unsure about or worried might be harder than it looks?"

### Phase 3: Brief Generation

After all questions answered (or after 7 questions max), generate a structured brief:

```markdown
# Task Brief: [concise title]

**Generated:** [date]
**Source:** deep-interview session

## Intent
[1-2 sentences: what should change]

## Trigger
[Why now — bug, request, debt, opportunity]

## Scope
**In scope:**
- [concrete item 1]
- [concrete item 2]

**Out of scope:**
- [concrete exclusion 1]
- [concrete exclusion 2]

## Constraints
- [constraint 1]
- [constraint 2]

## Success Criteria
- [ ] [measurable criterion 1]
- [ ] [measurable criterion 2]

## Open Questions
- [anything unresolved]

## Relevant Code
- `path/to/file.ts` — [why relevant]
- `path/to/other.py` — [why relevant]

## Suggested Next Step
[One of: brainstorming, writing-plans, background implementation workflow, direct implementation]
```

### Phase 4: Handoff

Present the brief to user. Then suggest next step based on complexity:

| Complexity | Suggested next step |
|-----------|-------------------|
| Simple (1-2 files, clear path) | "Ready to implement directly" |
| Medium (clear but multi-file) | "Ready for `/writing-plans` — skip brainstorming" |
| Complex (architectural decisions needed) | "Ready for brainstorming → writing-plans" |
| Large (multi-day, parallel work) | "Ready for brainstorming → writing-plans → parallel implementation" |

**Do NOT auto-invoke the next step.** Present the brief, suggest the step, let the user decide.

If user confirms, save the brief to the project:
- Save to `docs/briefs/[date]-[slug].md` (create dir if needed)
- Or wherever the user prefers

---

## Example Session

```
User: /deep-interview add notifications to the app

Claude: [reads codebase, finds a web app with no notification system]

Claude: "What kind of notifications? Push notifications to mobile,
        in-app toasts, email, or a chat integration?"

User: "in-app + email"

Claude: "Got it. What events should trigger a notification? I can see
        sign-up, checkout, and password reset flows in the codebase."

[... continues one question at a time ...]

Claude: [generates brief, suggests writing-plans as next step]
```

---

## Anti-patterns

- Asking 5 questions at once — defeats the purpose
- Generic questions not grounded in codebase context — waste of time
- Going beyond 7 questions — diminishing returns, user gets annoyed
- Auto-starting brainstorming/planning without user confirmation
- Writing code or making changes during interview
Files in this package (2)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB

Versions

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

Database snapshot: 13.11.2026 · package version 2e59f0816c62 (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.
  • 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.…
  • 100interview-me
    Interview the user about a plan or decision through structured one-at-a-time questioning until reaching consensus. Produces a design brief artifact or hands off when the user signals readiness. Use when an idea is vague and needs shaping before planning or implementation begins.…
  • 100clarify
    Refine an existing feature specification through targeted clarification dialogue. Use when a spec.md contains ambiguities — vague roles, non-testable requirements, unclear entities — that should be resolved before generating the doc chain.
  • 90interview-me
    Interview the user about a plan, idea, or design through a short sequence of high-leverage questions, then summarize the direction and next step. Use when the user wants a relaxed interview, lightweight clarification, or says "interview me", without exhaustive grilling.
  • 90interview-me
    Interview the user one question at a time before starting a big or fuzzy task, then write the brief and execute it. Use when the user says "interview me", "brief me", "help me brief this", "I don't know where to start", or hands over a large task with obvious gaps in the…

Feedback and reports

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