home / skills / team-attention / plugins-for-claude-natives / clarify

clarify skill

/plugins/clarify/skills/clarify

This skill helps clarify vague requirements through structured questioning, delivering precise goals, scope, constraints, and success criteria for actionable

npx playbooks add skill team-attention/plugins-for-claude-natives --skill clarify

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

Files (1)
SKILL.md
4.6 KB
---
name: clarify
description: This skill should be used when the user asks to "clarify requirements", "refine requirements", "specify requirements", "what do I mean", "make this clearer", or when the user's request is ambiguous and needs iterative questioning to become actionable. Also trigger when user says "clarify", "/clarify", or mentions unclear/vague requirements.
---

# Clarify

Transform vague or ambiguous requirements into precise, actionable specifications through iterative questioning.

## Purpose

When requirements are unclear, incomplete, or open to multiple interpretations, use structured questioning to extract the user's true intent before any implementation begins.

## Protocol

### Phase 1: Capture Original Requirement

Record the original requirement exactly as stated:

```markdown
## Original Requirement
"{user's original request verbatim}"
```

Identify ambiguities:
- What is unclear or underspecified?
- What assumptions would need to be made?
- What decisions are left to interpretation?

### Phase 2: Iterative Clarification

Use AskUserQuestion tool to resolve each ambiguity. Continue until ALL aspects are clear.

**Question Design Principles:**
- **Specific over general**: Ask about concrete details, not abstract preferences
- **Options over open-ended**: Provide 2-4 choices (recognition > recall)
- **One concern at a time**: Avoid bundling multiple questions
- **Neutral framing**: Present options without bias

**Loop Structure:**
```
while ambiguities_remain:
    identify_most_critical_ambiguity()
    ask_clarifying_question()  # Use AskUserQuestion tool
    update_requirement_understanding()
    check_for_new_ambiguities()
```

**AskUserQuestion Format:**
```
question: "What authentication method should be used?"
options:
  - label: "Username/Password"
    description: "Traditional email/password login"
  - label: "OAuth"
    description: "Google, GitHub, etc. social login"
  - label: "Magic Link"
    description: "Passwordless email link"
```

### Phase 3: Before/After Comparison

After clarification is complete, present the transformation:

```markdown
## Requirement Clarification Summary

### Before (Original)
"{original request verbatim}"

### After (Clarified)
**Goal**: [precise description of what user wants]
**Scope**: [what's included and excluded]
**Constraints**: [limitations, requirements, preferences]
**Success Criteria**: [how to know when done]

**Decisions Made**:
| Question | Decision |
|----------|----------|
| [ambiguity 1] | [chosen option] |
| [ambiguity 2] | [chosen option] |
```

### Phase 4: Save Option

Ask if the user wants to save the clarified requirement:

```
AskUserQuestion:
question: "Save this requirement specification to a file?"
options:
  - label: "Yes, save to file"
    description: "Save to requirements/ directory"
  - label: "No, proceed"
    description: "Continue without saving"
```

If saving:
- Default location: `requirements/` or project-appropriate directory
- Filename: descriptive, based on requirement topic (e.g., `auth-feature-requirements.md`)
- Format: Markdown with Before/After structure

## Ambiguity Categories

Common types to probe:

| Category | Example Questions |
|----------|------------------|
| **Scope** | What's included? What's explicitly out? |
| **Behavior** | Edge cases? Error scenarios? |
| **Interface** | Who/what interacts? How? |
| **Data** | Inputs? Outputs? Format? |
| **Constraints** | Performance? Compatibility? |
| **Priority** | Must-have vs nice-to-have? |

## Examples

### Example 1: Vague Feature Request

**Original**: "Add a login feature"

**Clarifying questions (via AskUserQuestion)**:
1. Authentication method? → Username/Password
2. Registration included? → Yes, self-signup
3. Session duration? → 24 hours
4. Password requirements? → Min 8 chars, mixed case

**Clarified**:
- Goal: Add username/password login with self-registration
- Scope: Login, logout, registration, password reset
- Constraints: 24h session, bcrypt, rate limit 5 attempts
- Success: User can register, login, logout, reset password

### Example 2: Bug Report

**Original**: "The export is broken"

**Clarifying questions**:
1. Which export? → CSV
2. What happens? → Empty file
3. When did it start? → After v2.1 update
4. Steps to reproduce? → Export any report

**Clarified**:
- Goal: Fix CSV export producing empty files
- Scope: CSV only, other formats work
- Constraint: Regression from v2.1
- Success: CSV contains correct data matching UI

## Rules

1. **No assumptions**: Ask, don't assume
2. **Preserve intent**: Refine, don't redirect
3. **Minimal questions**: Only what's needed
4. **Respect answers**: Accept user decisions
5. **Track changes**: Always show before/after

Overview

This skill transforms vague or ambiguous user requests into precise, actionable requirement specifications through iterative, focused questioning. It captures the original request, identifies ambiguities, asks targeted multiple-choice questions, and produces a clear before/after requirement summary. It can optionally save the clarified specification as a Markdown file in a project-appropriate location.

How this skill works

First, the skill records the user's original requirement verbatim and scans it for ambiguity across scope, behavior, interface, data, constraints, and priority. It then runs an iterative loop of single-topic, option-based questions until all ambiguities are resolved, updating its internal specification each step. Finally, it emits a Requirement Clarification Summary with goal, scope, constraints, success criteria, and a table of decisions, and offers to save the result to a requirements/ file.

When to use it

  • User asks to "clarify", "/clarify", or explicitly requests clarification or refinement
  • A request is vague, underspecified, or could be interpreted multiple ways
  • Before starting implementation, planning, or estimating work
  • When a bug report or feature request lacks reproducible detail
  • When stakeholder input conflicts or leaves critical decisions open

Best practices

  • Ask specific, single-concern questions rather than broad ones
  • Prefer 2–4 concrete options for each question to reduce friction
  • Preserve the user’s original intent—don’t reframe goals without permission
  • Only ask the minimal number of questions needed to remove ambiguity
  • Record every decision and present a before/after comparison for traceability
  • Offer a save option to standardize requirement storage in the project

Example use cases

  • Turning "Add a login feature" into a full auth specification (method, session, password policy)
  • Refining a bug report like "export is broken" into a reproducible defect with scope and steps
  • Clarifying API requirements: request/response formats, auth, error handling, and rate limits
  • Converting stakeholder feature notes into acceptance criteria and success metrics
  • Creating a shareable requirements.md for handoff to design or engineering

FAQ

How many questions will you ask?

I ask only what’s needed: the loop continues until all ambiguities are resolved, typically a handful of focused questions per ambiguity.

Can you save the clarified requirement automatically?

Yes. I offer a save option with a default requirements/ location and a descriptive filename; you can accept or decline.