home / skills / secondsky / claude-skills / plan-interview

This skill transforms rough plans into implementation-ready specifications through adaptive, interview-driven questioning and structured requirement gathering.

npx playbooks add skill secondsky/claude-skills --skill plan-interview

Review the files below or copy the command above to add this skill to your agents.

Files (7)
SKILL.md
3.4 KB
---
name: plan-interview
description: Adaptive interview-driven spec generation. Use when converting rough plans into comprehensive specifications, needing structured requirements gathering, or transforming ideas into implementation-ready documentation.
---

# Plan Interview Skill

Transform rough plans into comprehensive, implementation-ready specifications through adaptive, structured interviews.

## When to Use

- Converting a plan or idea into a detailed specification
- Gathering requirements through structured questioning
- Transforming rough documentation into implementation-ready specs
- Ensuring all edge cases, risks, and stakeholders are considered before implementation

## Available Components

### Command: `/plan-interview:interview [plan-file]`

Adaptive interview that calibrates depth based on plan complexity:

| Complexity | Signals | Questions |
|------------|---------|-----------|
| **Simple** | Single feature, clear scope | 10-15 |
| **Moderate** | Multi-component, some integrations | 18-23 |
| **Complex** | Cross-system, many stakeholders | 22-28 |

**Usage:**
```bash
/plan-interview:interview docs/feature-plan.md
# Output: docs/feature-plan-spec.md
```

### Agent: `spec-reviewer`

Autonomous quality analysis of specifications across 4 dimensions:
- **Completeness** (25 pts) - All sections populated?
- **Consistency** (25 pts) - No contradictions?
- **Clarity** (25 pts) - No ambiguous language?
- **Edge Cases** (25 pts) - Error handling defined?

Triggers when you say "review my spec" or "check specification quality".

## Interview Phases

1. **Foundations & Scope** - Stakeholders, success criteria, constraints, MVP scope
2. **Technical Deep-Dive** - Architecture, data models, scalability, security
3. **User Experience** - Personas, flows, cognitive load, error recovery
4. **Risks & Tradeoffs** - Risk categorization, blast radius, contingency plans
5. **Operationalization** - Testing, deployment, monitoring
6. **Wrap-Up** (optional) - Only for complex plans with remaining gaps

## Interview Philosophy

**Core Principle**: Depth over breadth. Better to deeply understand critical aspects than superficially cover everything.

**Key Techniques**:
- Non-obvious questions - Skip what the plan already answers
- Edge probing - What happens in unusual cases?
- Assumption surfacing - Make implicit beliefs explicit
- Contradiction detection - Flag when answers don't align
- Adaptive depth - Probe deeper on complex areas, move faster on clear ones

## Spec Output Structure

Generated specs include:
- Overview (problem, solution, success criteria, stakeholders)
- Functional and non-functional requirements
- Technical design (architecture, data models, APIs, security)
- User experience (personas, flows, states, edge cases)
- Risks and mitigations (risk register, tradeoffs, contingency plans)
- Implementation notes (key decisions, dependencies, migration)
- Operationalization (testing, deployment, monitoring)
- Open questions and out-of-scope items
- Phasing (MVP vs future)

## References

Load these for deeper guidance during interviews:
- `references/phase-1-clarifications.md` - Foundations questions and pitfalls
- `references/phase-2-technical.md` - Architecture discussion patterns
- `references/phase-3-ux.md` - Persona development, UX patterns
- `references/phase-4-risks.md` - Risk assessment frameworks
- `references/interview-techniques.md` - Cross-cutting interview skills
- `references/example-spec.md` - Annotated high-quality spec example

Overview

This skill runs adaptive, interview-driven sessions to convert rough plans into comprehensive, implementation-ready specifications. It asks targeted questions, surfaces assumptions, and produces a structured spec including technical design, UX, risks, and operationalization. Use it to ensure requirements are complete, consistent, and actionable before implementation.

How this skill works

You point the skill at a plan or outline and it calibrates question depth based on complexity, running a phased interview from scope to operationalization. It probes foundations, technical design, UX, risks, and deployment details, skipping what the plan already covers and digging deeper where gaps or contradictions appear. The output is a ready-to-use spec document and an autonomous spec-review that scores completeness, clarity, consistency, and edge-case coverage.

When to use it

  • Converting a one-page plan or rough brief into a full product or feature spec
  • Running a structured requirements-gathering session with engineers, PMs, and designers
  • Validating that edge cases, failure modes, and security considerations are covered
  • Preparing implementation-ready documentation before sprint planning or handoff
  • Breaking down multi-component or cross-team initiatives into phased deliverables

Best practices

  • Provide the existing plan or notes to seed the interview and reduce repetition
  • Invite key stakeholders (tech, product, design, ops) into the interview loop
  • Start with a simple run for MVP scope, then trigger deeper phases for complex areas
  • Treat the spec output as living: iterate after implementation discoveries
  • Use the spec-reviewer output to prioritize open questions and remaining gaps

Example use cases

  • Turn a product manager’s feature brief into a developer-ready spec with APIs and data models
  • Conduct pre-planning interviews for a cross-team integration to identify dependencies and risks
  • Generate a phased rollout plan (MVP vs later) with monitoring and rollback strategies
  • Audit existing design docs to find ambiguous requirements and missing error handling
  • Rapidly produce implementation notes and testing criteria for handoff to an engineering squad

FAQ

How many questions will the interview ask?

The interview adapts to plan complexity: roughly 10–15 for simple plans, 18–23 for moderate, and 22–28 for complex plans.

What does the spec-reviewer evaluate?

It scores the spec across completeness, consistency, clarity, and edge-case coverage, and highlights contradictions and open questions.