interview_skill

Overview

This skill interviews you in depth about a plan you provide and turns that conversation into a polished specification file. It accepts either a path to an existing plan file or raw plan text, captures detailed answers through iterative questioning, and writes the completed spec to a file. The focus is on rigorous, non-obvious questions that probe technical, UX, risk, and tradeoff details.

How this skill works

On input, the skill detects whether the text is a file path or raw plan content. If a path is supplied, it reads that file as the initial plan; if raw text is supplied, it generates a timestamped filename and stores the initial plan. It then conducts a continuous, deep interview using iterative, specific questions until all aspects are clarified, and finally writes the final specification back to the chosen file.

When to use it

• You have a rough project idea or brief and need a full, production-ready spec.
• You want to expand a one-paragraph plan into a detailed implementation roadmap.
• You received a draft file and need structured follow-up questions to refine it.
• You need to capture stakeholder decisions and tradeoffs in a persistent spec.
• You want a persistent, timestamped record of interview-driven requirements.

Best practices

• Provide either the raw plan text or a clear file path to start; ambiguous inputs slow the flow.
• Expect multiple rounds of targeted questions; answer with concrete constraints, priorities, and examples.
• Be explicit about non-functional requirements (performance, scale, security) early in the interview.
• Flag assumptions and unknowns during answers so the skill can probe them further.
• Review the generated filename and final spec after the interview to confirm context and naming.

Example use cases

• Turn a short product idea into a full engineering specification with API, data, and UX requirements.
• Refine a README or draft roadmap by asking deep implementation and deployment questions.
• Interview stakeholders to capture acceptance criteria, edge cases, and operational considerations.
• Create a timestamped, traceable spec file for audits or handoffs to engineering teams.
• Explore tradeoffs between architectures (monolith vs microservices), storage options, and UX flows through targeted questioning.