interview

Gather requirements and clarify unknowns through adaptive multi-round interviews.

Updated Apr 3, 2026

Search Tags:#planning #debugging #verification #interview #requirements gathering #tradeoffs

Ready to run

npx skills add https://github.com/robertdp/claude-code-skills --skill interview-robertdp

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: interview
Source: https://github.com/robertdp/claude-code-skills/tree/main/skills/interview
Command: npx skills add https://github.com/robertdp/claude-code-skills --skill interview-robertdp

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you gather requirements, surface unknowns, and clarify tradeoffs before making decisions or starting implementation. It reduces rework by turning vague requests into structured, verified understanding.

Core Features & Use Cases

Adaptive questioning: Asks 2–4 focused questions per round and adjusts based on answers and context.
Context-aware research: Checks codebase structure and relevant external sources when answers need verification.
Decision framing: Organizes technical, product, and problem-solving conversations into clear constraints, assumptions, and next steps.
Use case: Use it when a user says they need help planning a feature, debugging a problem, or deciding between implementation options.

Quick Start

Use the interview skill to gather requirements for my project and identify the key constraints, unknowns, and tradeoffs before we plan the work.

Frequently Asked Questions about interview

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I gather requirements before starting software implementation?▼

Requirements gathering before implementation involves adaptive multi-round questioning to clarify unknowns, identify constraints, and surface tradeoffs. This approach turns vague requests into structured, verified understanding of goals, assumptions, and risks, reducing rework.

When do I need structured questioning for debugging a technical problem?▼

Structured questioning for debugging is needed when a problem lacks clear reproduction steps or root cause context. Adaptive interviews help verify assumptions, gather relevant context from codebase or web sources, and frame the tradeoffs before applying a fix.

What's the best way to plan a feature with unclear constraints and unknowns?▼

Planning a feature with unclear constraints requires adaptive multi-round interviews that ask focused questions, verify answers against codebase structure, and summarize goals, assumptions, and risks into actionable next steps before implementation begins.

Can I use adaptive questioning to analyze tradeoffs between implementation options?▼

Yes, adaptive questioning frames implementation tradeoff analysis by organizing technical and product conversations into structured constraints, assumptions, and risks. It asks targeted questions per round and adjusts based on your answers to clarify the best path forward.

Does requirements gathering work for both technical and product conversations?▼

Requirements gathering applies to technical, product, and debugging conversations alike. It uses adaptive multi-round interviews to clarify unknowns, verify context from code or external sources, and structure decisions across different domains.

Why does my feature planning fail when I skip clarifying unknowns and assumptions?▼

Feature planning fails without clarifying unknowns because vague requests hide critical constraints, assumptions, and risks. Structured requirements gathering surfaces these factors through adaptive questioning and context verification before implementation begins.