Skip to content
Skills Library
Management & product · Planning

interview

/interview

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.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 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.
Content25 / 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 27.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

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.

Arguments

/interview <topic or feature description>
Original author description

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.

How it works

  1. Critical Rules
  2. Phase 1: Context Gathering
  3. Phase 2: Interview
  4. Phase 3: Write the Plan
Original SKILL.md headings · 94 lines, 619 words
SKILL.md preview
---
name: interview
description: 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.
disable-model-invocation: true
user-invocable: true
argument-hint: "<topic or feature description>"
---

# Interview

Conduct a detailed interview to gather requirements and produce a written specification. The interview starts broad (problem discovery) and progressively converges toward a concrete implementation plan.

$ARGUMENTS

## Critical Rules

**ALWAYS:**
- Explore the codebase BEFORE asking questions — understand existing patterns, models, and domain concepts first
- Use `AskUserQuestion` for every interview question — never assume answers
- Ask ONE focused question at a time (with 2-4 options when appropriate) — avoid walls of questions
- Write the final plan to a file, not just chat output
- Write the plan in the same language the user uses

**NEVER:**
- Skip Phase 1 (context gathering) — uninformed questions waste the user's time
- Ask more than 2 questions per turn
- Continue interviewing when you have enough information — converge and write the plan

## Phase 1: Context Gathering

Before asking any questions, silently explore the codebase to understand:

1. **Existing architecture** — project structure, key patterns, frameworks in use
2. **Related features** — similar functionality that already exists
3. **Domain concepts** — models, entities, terminology from the codebase and docs/
4. **Conventions** — naming, file organization, testing patterns

This phase is silent — do not narrate what you're reading. Use the knowledge to ask informed questions.

## Phase 2: Interview

### Calibration (First Question)

Start by understanding the scope. Based on the user's initial description and what you found in Phase 1, calibrate the interview depth:

- **Small** (bug fix, config change, minor tweak): 2-4 questions, focus on the specific problem
- **Medium** (new endpoint, new component, feature extension): 4-8 questions, cover happy path + edge cases
- **Large** (new subsystem, architectural change, cross-cutting feature): 8-15 questions, cover all areas below

Tell the user the estimated scope and question count so they know what to expect.

### Interview Flow

Progress through these stages in order. Skip stages that don't apply to the scope.

#### Stage 1: Problem Discovery
- What problem does this solve? Why now?
- Who are the users? What are their goals?
- What happens today without this feature?

#### Stage 2: Solution Shape
- What does the happy path look like end to end?
- What variations or modes exist?
- How does this interact with existing features?

#### Stage 3: Edge Cases & Constraints
- What can go wrong? How should errors be handled?
- Are there performance, security, or data constraints?
- What is explicitly out of scope (for now)?

#### Stage 4: Implementation Details
- Data model implications — new entities, schema changes, migrations?
- UI/UX flow and states (if applicable)?
- API surface — endpoints, contracts, versioning?
- What needs to be tested? What are the acceptance criteria?

### Convergence Criteria

Stop interviewing when ALL of these are true:

1. You can describe the happy path without any gaps
2. Error handling and edge cases are addressed
3. The technical approach is clear (no hand-waving)
4. Scope boundaries are explicit (what's in, what's out)

If you're unsure whether you have enough, ask one final confirmation question summarizing your understanding and asking if anything is missing.

## Phase 3: Write the Plan

Write the plan to a markdown file in the project. Default location: `docs/plans/` directory, or the project root if no docs/ exists. Use a descriptive filename based on the feature (e.g., `docs/plans/user-export-feature.md`).

Ask the user where to save it if the location isn't obvious.

Follow the template in `references/plan-template.md` for structure. Adapt sections based on scope — small features don't need every section.

### After Writing

- Show the user the file path
- Offer to refine any section
- If the user wants to iterate, update the file in place rather than rewriting from scratch
Files in this package (2)
  • SKILL.md 4 KB
  • references/plan-template.md 2 KB

Versions

RepositoryScoreLicence
This page · atc-net/atc-agentic-toolkit90MIT
q00/ouroboros100MIT
vanducng/skills100MIT
boshu2/agentops100Apache-2.0
mthines/agent-skills100MIT
r3dlex/oh-my-auggie100Apache-2.0
YuDefine/nuxt-supabase-starter100MIT
biliboss/skills100MIT
Soe-Reh/soes-skills100MIT

Database snapshot: 13.11.2026 · package version d8a292e34990 (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

  • 100deep-interview
    Start a structured interview to gather requirements for complex features. Use when tackling multi-layer features, validating PRDs, or defining scope for implementation.
  • 100deep-interview
    Use when a vague task needs a clarification interview and structured brief. Triggers — "clarify task", "define requirements".
  • 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.…
  • 90interview-me
    Turn a fuzzy goal into a structured, living plan doc — by interview (the architect) or quick capture (Hermes). Use for a "help me plan / think this through" request or the //plan command. (Named to avoid a builtin `plan` skill.)
  • 100interview-me
    Conduct an adaptive interactive interview on any topic and produce a structured markdown report, summary, or implementation plan. Use when the user says "interview me", "interview me about", "run an interview on", "help me think through", or wants guided discovery on any…
  • 100spec
    Interview the user about a feature or project, then write a spec they can build from. Use when the user wants to plan, scope or spec something before coding, or runs /spec with an idea.

Feedback and reports

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