编写规范

---
name: write-spec
description: >-
  Write a feature spec or PRD from a problem statement or feature idea. Use when turning a
  vague idea or user request into a structured document, scoping a feature with goals and
  non-goals, defining success metrics and acceptance criteria, or breaking a big ask into
  a phased spec.
slug: write-spec
version: 1.2.0
displayName: write-spec
---

# Write Spec

## 中文速览（Quick Guide）

- **做什么**：把一个问题陈述或功能想法写成结构化特性规格/PRD，界定目标与非目标、成功指标与验收标准，并按需分期。
- **何时用**：需求还模糊需要定范围、定义成功指标与验收标准、或把大需求拆成分期规格时；纯实现计划、缺陷记录、已有规格再拆票、以及还讲不清用户问题时都不适用。
- **核心步骤**：①弄清要规格化的功能或问题；②逐个收集用户问题、目标用户、成功指标、约束与既有方案；③写 Problem Statement 与 Goals/Non-goals、指标、验收标准，冲突写入 Open Questions；④范围过大则分期、只详写第一期。
- **国内可达性**：本技能为纯文档撰写，不依赖外部连接器或境外在线服务；未连接的工具段落跳过，不编造工单或调研引用。

> Placeholders like `$ARGUMENTS` are filled from the user invocation; no external connectors file is required for this skill.

Write a feature specification or product requirements document (PRD).

**Related skills:** pair with `problem-statement` when the user problem is still vague, `prd-development`/`prd-driven-ddd` when the spec feeds a DDD-driven build, and `roadmap-planning` when phasing spans multiple releases.

## Usage

```
/write-spec $ARGUMENTS
```

## When NOT to Use This

- The ask is an engineering implementation plan (task breakdown, sequencing) → use a planning skill; this skill produces the *what and why*, not the *how*.
- The ask is a bug report or incident write-up → that is post-hoc documentation, not a feature spec.
- The feature is already specced and you only need tickets broken out → feed the existing spec to a ticketing step instead of regenerating a PRD.
- You cannot articulate any user problem yet — write a problem statement first; a PRD built on a phantom problem is worse than no PRD.

## Failure Exits and Edge Handling (observable)

| Situation | Observable exit |
|-----------|-----------------|
| `$ARGUMENTS` is empty and the user gives no goal | Ask one question: "What problem should this spec solve?" Do **not** generate a placeholder PRD. |
| User gives only a solution ("add a dropdown") | Restate the underlying user problem in one sentence and confirm before writing Goals. |
| Conflicting constraints stated (e.g., "ship in 1 week" + "rewrite auth") | Surface the conflict explicitly in **Open Questions** tagged to the decision owner; do not silently pick a side. |
| Connected-tool sections reference tools that are not connected | Skip them and proceed from user-provided info only (per Workflow step 3); do not fabricate ticket or research references. |
| Scope too big for one spec | Stop expanding; propose phasing and spec only phase 1 (per Tips). |

## Minimal Worked Example

**Preconditions:** user invokes with a feature idea and answers a couple of context questions.

**Invocation:**

```
/write-spec Users want to export their data as CSV; enterprise admins keep asking
```

**Excerpt of the produced PRD (what "done" looks like):**

```markdown
# Spec: CSV Data Export

## Problem Statement
Enterprise admins need data out of the product for reporting, but today must
request manual extracts — a 2-day turnaround per request. (Evidence: 14 support
tickets in Q3.)

## Goals
- Reduce admin time-to-data from 2 days to under 5 minutes

## Non-Goals
- Scheduled/recurring exports — separate initiative, needs scheduler infra
- XLSX or JSON formats — CSV covers 90% of requests; formats are a fast follow

## Requirements
### Must-Have (P0)
- Admin can export the members list as CSV — Given an admin on the members page,
  When they click "Export CSV", Then a download starts within 10 seconds
...
```

## Common Mistakes → Fixes

| Mistake | Symptom | Fix |
|---------|---------|-----|
| Goals are outputs, not outcomes | "Build an export wizard" | Restate as measurable change: "reduce time-to-data to under 5 minutes" |
| Non-goals missing | Spec grows every review | Add 3-5 explicit non-goals with one-line rationale each |
| Every requirement is P0 | "If everything is P0, nothing is P0" | Challenge each: "Would we really not ship without this?" |
| Acceptance criteria say "user-friendly" | Untestable | Rewrite in Given/When/Then with observable behavior |
| User story prescribes UI | "I want a dropdown" | Rewrite around the need: "I want to filter members by status" |
| Open questions answerable from context | Noise for stakeholders | Only list genuinely open questions with a named owner |

## Workflow

### 1. Understand the Feature

Ask the user what they want to spec. Accept any of:
- A feature name ("SSO support")
- A problem statement ("Enterprise customers keep asking for centralized auth")
- A user request ("Users want to export their data as CSV")
- A vague idea ("We should do something about onboarding drop-off")

### 2. Gather Context

Ask the user for the following. Be conversational — do not dump all questions at once. Ask the most important ones first and fill in gaps as you go:

- **User problem**: What problem does this solve? Who experiences it?
- **Target users**: Which user segment(s) does this serve?
- **Success metrics**: How will we know this worked?
- **Constraints**: Technical constraints, timeline, regulatory requirements, dependencies
- **Prior art**: Has this been attempted before? Are there existing solutions?

### 3. Pull Context from Connected Tools

If **~~project tracker** is connected:
- Search for related tickets, epics, or features
- Pull in any existing requirements or acceptance criteria
- Identify dependencies on other work items

If **~~knowledge base** is connected:
- Search for related research documents, prior specs, or design docs
- Pull in relevant user research findings
- Find related meeting notes or decision records

If **~~design** is connected:
- Pull related mockups, wireframes, or design explorations
- Search for design system components relevant to the feature

If these tools are not connected, work entirely from what the user provides. Do not ask the user to connect tools — just proceed with available information.

### 4. Generate the PRD

Produce a structured PRD with these sections. See **PRD Structure** below for detailed guidance on what each section should contain.

- **Problem Statement**: The user problem, who is affected, and impact of not solving it (2-3 sentences)
- **Goals**: 3-5 specific, measurable outcomes tied to user or business metrics
- **Non-Goals**: 3-5 things explicitly out of scope, with brief rationale for each
- **User Stories**: Standard format ("As a [user type], I want [capability] so that [benefit]"), grouped by persona
- **Requirements**: Categorized as Must-Have (P0), Nice-to-Have (P1), and Future Considerations (P2), each with acceptance criteria
- **Success Metrics**: Leading indicators (change quickly) and lagging indicators (change over time), with specific targets
- **Open Questions**: Unresolved questions tagged with who needs to answer (engineering, design, legal, data)
- **Timeline Considerations**: Hard deadlines, dependencies, and phasing

### 5. Review and Iterate

After generating the PRD:
- Ask the user if any sections need adjustment
- Offer to expand on specific sections
- Offer to create follow-up artifacts (design brief, engineering ticket breakdown, stakeholder pitch)

## PRD Structure

### Problem Statement
- Describe the user problem in 2-3 sentences
- Who experiences this problem and how often
- What is the cost of not solving it (user pain, business impact, competitive risk)
- Ground this in evidence: user research, support data, metrics, or customer feedback

### Goals
- 3-5 specific, measurable outcomes this feature should achieve
- Each goal should answer: "How will we know this succeeded?"
- Distinguish between user goals (what users get) and business goals (what the company gets)
- Goals should be outcomes, not outputs ("reduce time to first value by 50%" not "build onboarding wizard")

### Non-Goals
- 3-5 things this feature explicitly will NOT do
- Adjacent capabilities that are out of scope for this version
- For each non-goal, briefly explain why it is out of scope (not enough impact, too complex, separate initiative, premature)
- Non-goals prevent scope creep during implementation and set expectations with stakeholders

### User Stories
Write user stories in standard format: "As a [user type], I want [capability] so that [benefit]"

Guidelines:
- The user type should be specific enough to be meaningful ("enterprise admin" not just "user")
- The capability should describe what they want to accomplish, not how
- The benefit should explain the "why" — what value does this deliver
- Include edge cases: error states, empty states, boundary conditions
- Include different user types if the feature serves multiple personas
- Order by priority — most important stories first

Example:
- "As a team admin, I want to configure SSO for my organization so that my team members can log in with their corporate credentials"
- "As a team member, I want to be automatically redirected to my company's SSO login so that I do not need to remember a separate password"
- "As a team admin, I want to see which members have logged in via SSO so that I can verify the rollout is working"

### Requirements

**Must-Have (P0)**: The feature cannot ship without these. These represent the minimum viable version of the feature. Ask: "If we cut this, does the feature still solve the core problem?" If no, it is P0.

**Nice-to-Have (P1)**: Significantly improves the experience but the core use case works without them. These often become fast follow-ups after launch.

**Future Considerations (P2)**: Explicitly out of scope for v1 but we want to design in a way that supports them later. Documenting these prevents accidental architectural decisions that make them hard later.

For each requirement:
- Write a clear, unambiguous description of the expected behavior
- Include acceptance criteria (see below)
- Note any technical considerations or constraints
- Flag dependencies on other teams or systems

### Open Questions
- Questions that need answers before or during implementation
- Tag each with who should answer (engineering, design, legal, data, stakeholder)
- Distinguish between blocking questions (must answer before starting) and non-blocking (can resolve during implementation)

### Timeline Considerations
- Hard deadlines (contractual commitments, events, compliance dates)
- Dependencies on other teams' work or releases
- Suggested phasing if the feature is too large for one release

## User Story Writing

Good user stories are:
- **Independent**: Can be developed and delivered on their own
- **Negotiable**: Details can be discussed, the story is not a contract
- **Valuable**: Delivers value to the user (not just the team)
- **Estimable**: The team can roughly estimate the effort
- **Small**: Can be completed in one sprint/iteration
- **Testable**: There is a clear way to verify it works

### Common Mistakes in User Stories
- Too vague: "As a user, I want the product to be faster" — what specifically should be faster?
- Solution-prescriptive: "As a user, I want a dropdown menu" — describe the need, not the UI widget
- No benefit: "As a user, I want to click a button" — why? What does it accomplish?
- Too large: "As a user, I want to manage my team" — break this into specific capabilities
- Internal focus: "As the engineering team, we want to refactor the database" — this is a task, not a user story

## Requirements Categorization

### MoSCoW Framework
- **Must have**: Without these, the feature is not viable. Non-negotiable.
- **Should have**: Important but not critical for launch. High-priority fast follows.
- **Could have**: Desirable if time permits. Will not delay delivery if cut.
- **Won't have (this time)**: Explicitly out of scope. May revisit in future versions.

### Tips for Categorization
- Be ruthless about P0s. The tighter the must-have list, the faster you ship and learn.
- If everything is P0, nothing is P0. Challenge every must-have: "Would we really not ship without this?"
- P1s should be things you are confident you will build soon, not a wish list.
- P2s are architectural insurance — they guide design decisions even though you are not building them now.

## Success Metrics Definition

### Leading Indicators
Metrics that change quickly after launch (days to weeks):
- **Adoption rate**: % of eligible users who try the feature
- **Activation rate**: % of users who complete the core action
- **Task completion rate**: % of users who successfully accomplish their goal
- **Time to complete**: How long the core workflow takes
- **Error rate**: How often users encounter errors or dead ends
- **Feature usage frequency**: How often users return to use the feature

### Lagging Indicators
Metrics that take time to develop (weeks to months):
- **Retention impact**: Does this feature improve user retention?
- **Revenue impact**: Does this drive upgrades, expansion, or new revenue?
- **NPS / satisfaction change**: Does this improve how users feel about the product?
- **Support ticket reduction**: Does this reduce support load?
- **Competitive win rate**: Does this help win more deals?

### Setting Targets
- Targets should be specific: "50% adoption within 30 days" not "high adoption"
- Base targets on comparable features, industry benchmarks, or explicit hypotheses
- Set a "success" threshold and a "stretch" target
- Define the measurement method: what tool, what query, what time window
- Specify when you will evaluate: 1 week, 1 month, 1 quarter post-launch

## Acceptance Criteria

Write acceptance criteria in Given/When/Then format or as a checklist:

**Given/When/Then**:
- Given [precondition or context]
- When [action the user takes]
- Then [expected outcome]

Example:
- Given the admin has configured SSO for their organization
- When a team member visits the login page
- Then they are automatically redirected to the organization's SSO provider

**Checklist format**:
- [ ] Admin can enter SSO provider URL in organization settings
- [ ] Team members see "Log in with SSO" button on login page
- [ ] SSO login creates a new account if one does not exist
- [ ] SSO login links to existing account if email matches
- [ ] Failed SSO attempts show a clear error message

### Tips for Acceptance Criteria
- Cover the happy path, error cases, and edge cases
- Be specific about the expected behavior, not the implementation
- Include what should NOT happen (negative test cases)
- Each criterion should be independently testable
- Avoid ambiguous words: "fast", "user-friendly", "intuitive" — define what these mean concretely

## Scope Management

### Recognizing Scope Creep
Scope creep happens when:
- Requirements keep getting added after the spec is approved
- "Small" additions accumulate into a significantly larger project
- The team is building features no user asked for ("while we're at it...")
- The launch date keeps moving without explicit re-scoping
- Stakeholders add requirements without removing anything

### Preventing Scope Creep
- Write explicit non-goals in every spec
- Require that any scope addition comes with a scope removal or timeline extension
- Separate "v1" from "v2" clearly in the spec
- Review the spec against the original problem statement — does everything serve it?
- Time-box investigations: "If we cannot figure out X in 2 days, we cut it"
- Create a "parking lot" for good ideas that are not in scope

## Output Format

Use markdown with clear headers. Keep the document scannable — busy stakeholders should be able to read just the headers and bold text to get the gist.

## Tips

- Be opinionated about scope. It is better to have a tight, well-defined spec than an expansive vague one.
- If the user's idea is too big for one spec, suggest breaking it into phases and spec the first phase.
- Success metrics should be specific and measurable, not vague ("improve user experience").
- Non-goals are as important as goals. They prevent scope creep during implementation.
- Open questions should be genuinely open — do not include questions you can answer from context.