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.
- Author
- atc-net ↗
- Repository
- atc-agentic-toolkit ↗
- Licence
- MIT
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
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
- Critical Rules
- Phase 1: Context Gathering
- Phase 2: Interview
- Phase 3: Write the Plan
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
| Repository | Score | Licence |
|---|---|---|
| This page · atc-net/atc-agentic-toolkit | 90 | MIT |
| q00/ouroboros | 100 | MIT |
| vanducng/skills | 100 | MIT |
| boshu2/agentops | 100 | Apache-2.0 |
| mthines/agent-skills | 100 | MIT |
| r3dlex/oh-my-auggie | 100 | Apache-2.0 |
| YuDefine/nuxt-supabase-starter | 100 | MIT |
| biliboss/skills | 100 | MIT |
| Soe-Reh/soes-skills | 100 | MIT |
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.