interview-me
Use when a request is underspecified and you need to discover what the user actually wants before writing a plan, spec, or code - ask one question at a time, attach your current hypothesis, and stop only after the intent is explicitly confirmed.
Best use case
interview-me is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when a request is underspecified and you need to discover what the user actually wants before writing a plan, spec, or code - ask one question at a time, attach your current hypothesis, and stop only after the intent is explicitly confirmed.
Teams using interview-me should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/interview-me/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How interview-me Compares
| Feature / Agent | interview-me | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when a request is underspecified and you need to discover what the user actually wants before writing a plan, spec, or code - ask one question at a time, attach your current hypothesis, and stop only after the intent is explicitly confirmed.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Interview Me
Interview Me is for intent discovery before work starts. It is the step before a spec,
plan, or implementation, when the user's first ask may still be a proxy for the real
goal.
## When to Use
- The request is missing who, why, success criteria, constraints, or non-goals
- The user asked for a conventional artifact ("build a dashboard", "make it faster")
without saying what problem that artifact solves
- You notice yourself filling in assumptions before any plan exists
- The user explicitly asks to be interviewed, challenged, or stress-tested before starting
## When NOT to Use
| Instead of interview-me | Use |
|-------------------------|-----|
| The request is already clear and self-contained | do the task |
| The user's intent is already clear, but an existing plan or spec now needs its assumptions pressure-tested | `grill-me` |
| The work is really about choosing Copilot mode, tools, or delegation path rather than discovering the user's desired outcome | `task-intake-router` |
| The user asked a factual or explanatory question | answer directly |
## Loading Constraint
This skill needs a live user. Do not invoke it in non-interactive contexts where no one
can answer the questions.
## Workflow
### 1. State your hypothesis and confidence
Before asking anything, write down:
- your best current read of what the user wants
- a confidence number from 0 to 100
If the number feels high but you cannot predict the next few answers, the number is too high.
### 2. Ask one question at a time
Every question should include:
- one focused question
- your current guess for the answer
- the reasoning behind that guess
Do not batch several questions. The later questions depend on the earlier answers.
### 3. Listen for "want" vs "should want"
Probe when the user answers with:
- best-practice slogans
- vague quality words like "scalable" or "robust"
- conventional artifacts instead of outcomes
Useful probe:
> If you did not have to justify this to anyone, what would you actually want?
### 4. Restate the intent in a structured form
When confidence is high enough, write back:
- Outcome
- User
- Why now
- Success
- Constraint
- Out of scope
Out of scope is required. Many mismatches hide there.
### 5. Get an explicit yes
These do **not** count as confirmation:
- "whatever you think"
- "sounds good"
- silence followed by "let's start"
Keep refining until the user explicitly confirms the restated intent.
### 6. Stop when the intent is predictable
You are done when you can reasonably predict the user's reaction to the next few
questions you would ask.
Then hand off to the next skill:
- `create-prd` if the intent needs a product spec
- `grill-me` if a plan now exists but needs stress-testing
- direct implementation if the ask is now clear and bounded
## Output Template
```markdown
## Confirmed Intent
- Outcome: ...
- User: ...
- Why now: ...
- Success: ...
- Constraint: ...
- Out of scope: ...
Confirmed by user: Yes
```
## Common Rationalizations
| Rationalization | Reality |
|----------------|---------|
| "The ask is clear enough." | If you still need to guess the outcome, it is not clear enough. |
| "Questions will slow things down." | Building the wrong thing costs far more than 3 to 6 targeted questions. |
| "I'll discover the real goal while implementing." | That turns cheap clarification into expensive rework. |
## Red Flags
- Three or more questions in one message
- Questions without your current guess attached
- Producing a plan or spec before confirmation
- Skipping the out-of-scope line in the restatement
## Verification
- [ ] The first turn included a hypothesis and confidence number
- [ ] Questions were asked one at a time
- [ ] At least one probe tested for "want" vs "should want" when needed
- [ ] The restated intent included outcome, user, why now, success, constraint, and out of scope
- [ ] The user explicitly confirmed the restatement
## See Also
- [`grill-me`](../grill-me/SKILL.md) - pressure-test a plan that already exists
- [`task-intake-router`](../../copilot-exclusive/task-intake-router/SKILL.md) - route work to the right Copilot execution mode
- [`create-prd`](../../product/create-prd/SKILL.md) - turn confirmed intent into a product requirements documentRelated Skills
verification-before-completion
Use before claiming any task is done — run the exact command that proves the fix works, read the output, and only then report success.
using-git-worktrees
Use when you need multiple branches checked out at once — create isolated working directories for parallel development without cloning the repository repeatedly
triage
Use when a single issue needs structured triage — classify it, reproduce if needed, request missing information, and leave a durable brief or close-out note in the tracker.
to-issues
Use when a plan, spec, or PRD must become an actionable backlog — break it into thin dependency-aware issues that each deliver a verifiable vertical slice
sprint-workflow
Use when starting a new feature, refactor, or multi-step dev task — runs the full sprint cycle (Think → Plan → Build → Review → Test → Ship → Monitor) using Copilot CLI's plan/autopilot modes.
sprint-retro
Use at the end of a sprint to run a data-driven retrospective — analyzes session history and git metrics to surface what shipped, what slowed you down, and concrete improvements.
security-audit
Use when a codebase needs a formal security audit beyond a quick scan — applies OWASP Top 10 and STRIDE threat modeling from a CSO perspective to surface systemic vulnerabilities.
release
Use when a sprint or feature is complete and ready to ship — tags the version, generates GitHub Release notes, runs rollout or smoke verification, and publishes to npm/PyPI/Docker registries.
prompt-optimizer
Use when a rough prompt, vague idea, or task description needs to become a finished copy-pasteable prompt for a chat-based LLM - rewrite it into one ready-to-send prompt with no blanks, no placeholders, and a clear output shape.
outside-voice
Use when you need an independent second opinion before, during, or after implementation — run challenge, consult, or review mode in a direct builder-to-builder voice
llm-wiki
Use when research or domain knowledge keeps getting rediscovered across sessions — build a supplementary markdown wiki that compounds synthesized knowledge without replacing GitHub or committed project guidance
implementation-review
Use after an implementation pass lands — compare the original task spec or handoff against the delivered diff, classify each requested item, and produce an actionable follow-up report.