Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Pisanie

prd

/prd

Prowadzi przez pisanie PRD lub specyfikacji w czterech fazach: odkrycie, specyfikacja, plan i zadania.

Repozytorium
fsad_playbook ↗
Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

84/ 100Klasa: dobry
Format9 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi przez pisanie PRD lub specyfikacji w czterech fazach: odkrycie, specyfikacja, plan i zadania.

Wyzwalacze z opisu

s planning/prd/ directory. Use when the user sayswrite a specspec out this featurehelp me define requirements

Argumenty

/prd `[feature title or goal]`
Oryginalny opis (EN)

Guide the user through writing a Product Requirements Document or feature spec. Uses a four-phase gated flow (Discovery → Specify → Plan → Tasks) to produce spec.md, plan.md, and tasks.md in the project's planning/prd/ directory. Use when the user says "write a PRD", "write a spec", "spec out this feature", "help me define requirements", or similar.

Jak działa

  1. Asking the user
  2. Role definitions
  3. Success criteria (checkable, not prose)
  4. Step 0 — Parse arguments and establish context
  5. Phase 1 — Discovery (Analyst role)
  6. Phase 2 — Specify (PM role)
  7. Phase 3 — Plan (Technical design)
  8. Phase 4 — Tasks (Decomposition)
  9. Guardrails
  10. Analyst Role
Sekcje z nagłówków SKILL.md, w oryginale · 308 linii, 2 385 słów
Podgląd SKILL.md
---
description: Guide the user through writing a Product Requirements Document or feature spec. Uses a four-phase gated flow (Discovery → Specify → Plan → Tasks) to produce spec.md, plan.md, and tasks.md in the project's planning/prd/ directory. Use when the user says "write a PRD", "write a spec", "spec out this feature", "help me define requirements", or similar.
argument-hint: '`[feature title or goal]`'
---

# fsad-harness:prd — PRD & Spec Writing Agent

Follow these phases in order. Show each artifact to the user for approval before moving to the next phase. Never skip a gate.

## Asking the user

This rule covers every question this skill asks the user: a confirmation, a choice, a missing value, a numbered decision list, or a stop-and-ask. It applies even where a later step says "ask the user" or "ask exactly once". The user may watch the decisions pane rather than the chat, so a question that only goes to chat can go unanswered.

- **When `mcp__decision-tracker__decision` is in your tool list** (loaded, or named as a deferred tool; load a deferred one with `ToolSearch` first), log each question before you ask it:
  1. Call it with `action: "open"`, the question (ending in `?`), and `options` when the answers are a closed set. Set `required: false` when the work can go on without an answer. A numbered list of questions opens one decision per item. Keep each returned `id`.
  2. Ask the question in chat as this skill says. The open call does not replace the chat question.
  3. When the user answers, in chat or as a `Decision Dn: <answer>` message from the plugin, call the tool with `action: "close"`, the `id` and the answer.
  4. When the change the answer asked for is in place, call it with `action: "implement"`, the `id` and a `path:line`.
- **When the tool is absent**, ask in chat only.
- An `AskUserQuestion` call is logged on its own. Do not open it again.
- This rule changes where a question is logged. It does not change when this skill asks, or how many times.

## Role definitions

This skill uses two role briefs embedded below:
- **Analyst Role** — discovery interviewer (BMAD Analyst pattern)
- **PM Role** — spec-writing PM (GitHub Spec Kit PM pattern)

Read both role sections below before proceeding.

## Success criteria (checkable, not prose)

By the end of Phase 4, all of the following must hold. The Phase 4 verifier (below) checks these mechanically before the summary prints:

1. Every user story in `spec.md` has at least one falsifiable AC under it.
2. Every AC in `spec.md` is covered by at least one task's `acs` in `tasks.json`.
3. No task in `tasks.json` has an empty `acs` array.
4. No AC text matches a vague/unfalsifiable pattern (e.g. "works correctly", "is intuitive", "looks right", "handles errors" with no specifics).
5. `tasks.json` has no dependency cycles.

## Step 0 — Parse arguments and establish context

1. **Title/goal** — use the argument if provided. If empty, ask: *"What are you building or improving? Give me a one-line goal."*
2. **Project root** — determine the current working directory. This is the project root.
3. **Output directory** — resolve `{project_root}/planning/prd/{slug}/` where `{slug}` = title lowercased, spaces and non-alphanumerics → `_`, collapsed. Create the directory if it doesn't exist.
4. **Confirm the output path** to the user before starting: *"I'll write artifacts to `planning/prd/{slug}/`. Starting discovery now."*

## Phase 1 — Discovery (Analyst role)

Adopt the Analyst persona from the Analyst Role section below.

Track the five discovery goals from that section (problem framing, impact, success definition, constraints, scope boundaries) as a checklist. Ask discovery questions **one at a time** — never dump a list. Wait for each answer before asking the next.

**Condition-based loop, not a fixed count:** keep asking until every discovery goal has a concrete, non-vague answer, or until 8 questions have been asked (hard cap) — whichever comes first. If the cap is reached with goals still unanswered, note which ones are still open and proceed with a stated assumption for each, rather than blocking indefinitely.

When discovery is complete, summarize findings in 3–5 bullet points and ask the user: *"Does this capture the problem correctly? Anything to correct before I write the spec?"*

Incorporate corrections, then proceed to Phase 2.

## Phase 2 — Specify (PM role)

Adopt the PM persona from the PM Role section below.

Using the discovery summary, draft `spec.md` using the section structure from the PM Role:
- Problem Statement
- Target Users
- Goals / Non-Goals
- User Stories (numbered)
- Acceptance Criteria (per story, `- [ ]` checkboxes)
- Success Metrics
- Risks & Mitigations
- Dependencies

Every user story must have at least one AC under it (success criterion 1). Reject and rewrite any AC that matches a vague/unfalsifiable pattern before writing the file (success criterion 4) — e.g. "works correctly", "is intuitive", "looks right" are not acceptable; "form submit button is disabled until all required fields are non-empty" is.

Write the draft to `{output_dir}/spec.md`.

Show the draft path to the user and ask: *"`spec.md` written. Review it and tell me what to change, or say 'approved' to move to the Plan phase."*

Do not proceed until the user approves.

## Phase 3 — Plan (Technical design)

Ask the user: *"Any technical constraints I should know? (e.g. stack, existing APIs to reuse, performance requirements, auth model)"*

Wait for the answer. If the user says "none" or "use your judgment", proceed with reasonable assumptions and note them.

Draft `plan.md` containing:

```markdown
# [Feature Title] — Technical Plan

## Technical Approach
[How it will be built. Architecture, patterns, key decisions.]

## Key Components
- [Component / file / module and its responsibility]
- [Component / file / module and its responsibility]

## Data Model
[Schema changes, new types, or "no data model changes" if applicable.]

## Integrations & Dependencies
[External APIs, libraries, or services required.]

## Out of Scope (Technical)
[What technical work is explicitly deferred.]

## Assumptions
- [Technical assumption 1 — flag if wrong]
- [Technical assumption 2 — flag if wrong]
```

Write the draft to `{output_dir}/plan.md`.

Show the draft path and ask: *"`plan.md` written. Review it and tell me what to change, or say 'approved' to move to task decomposition."*

Do not proceed until the user approves.

## Phase 4 — Tasks (Decomposition)

Using `spec.md` and `plan.md` as inputs, decompose the work into a dependency-ordered task list.

### Structured output

Write `{output_dir}/tasks.json` first — this is the source of truth. Schema:

```json
{
  "feature": "[Feature Title]",
  "phases": [
    {
      "name": "[Phase name]",
      "tasks": [
        {
          "id": "T-001",
          "title": "[Task title]",
          "complexity": "S",
          "depends_on": [],
          "acs": ["[Specific, falsifiable acceptance criterion]"]
        },
        {
          "id": "T-002",
          "title": "[Task title]",
          "complexity": "M",
          "depends_on": ["T-001"],
          "acs": ["[Specific, falsifiable acceptance criterion]"]
        }
      ]
    }
  ]
}
```

**Complexity key:** `S` = a few hours, `M` = half day to a day, `L` = multi-day.

Rules:
- Number tasks sequentially (`T-001`, `T-002`, …) across the whole file, not per-phase.
- `depends_on` lists task IDs explicitly — `[]` if none.
- Every task's `acs` array has at least one entry (success criterion 3). Empty arrays are not valid.
- Every AC from `spec.md` must map to at least one task's `acs` (success criterion 2).
- Group into phases if there are 5+ tasks; a single `"General"` phase is fine for smaller feature sets.

Validate the JSON parses and every `depends_on` entry references a real task ID in the same file before moving on.

### Rendered view

After `tasks.json` is written and valid, render `{output_dir}/tasks.md` from it for human readability (same phase/task/AC structure as before, generated — not hand-authored):

```markdown
# [Feature Title] — Tasks

## Task List

### Phase 1: [Phase name]

- [ ] **T-001** (S) [Task title]
  - AC: [Specific, falsifiable acceptance criterion]

- [ ] **T-002** (M) [Task title]
  - Depends on: T-001
  - AC: [Specific, falsifiable acceptance criterion]
```

`tasks.json` is authoritative; `tasks.md` is a derived view — if they ever disagree after manual edits, regenerate `tasks.md` from `tasks.json`.

### Adversarial verification pass

Before presenting the final summary, run an independent verification pass over the finished artifacts:

1. **Read only `spec.md` and `tasks.json` from disk** — not this conversation's history, not the discovery notes, not your own drafting reasoning. The point is to catch what the drafting process itself was blind to; re-using that context would inherit the same blind spots.
2. Adopt a refuter stance: actively look for reasons the artifacts are *not* done, not reasons they're fine. Check each success criterion above mechanically:
   - Every user story has ≥1 AC? List any that don't.
   - Every spec AC is covered by ≥1 task's `acs`? List any orphaned ACs.
   - Every task has a non-empty `acs`? List any that don't.
   - Any AC text matches a vague/unfalsifiable pattern? Quote it.
   - Any dependency cycle in `depends_on`? Trace it.
3. If running as a subagent is available in this environment, prefer spawning a fresh subagent for this pass so it has no memory of the drafting conversation; otherwise perform the same read-only, disk-only pass inline, but explicitly disregard conversational context when judging the artifacts.
4. **If gaps are found:** fix them directly in `spec.md` and/or `tasks.json` (adding a missing AC, splitting a vague AC into falsifiable sub-criteria, adding a task for an orphaned AC, breaking a cycle), regenerate `tasks.md`, and re-run the check once more. Do not present the summary until a pass finds zero gaps.
5. **If zero gaps found on the first pass**, say so explicitly in the summary rather than silently skipping the step — the user should know the check ran.

Then present the summary:

> "`tasks.json`/`tasks.md` written to `planning/prd/{slug}/`. Adversarial verification pass: [zero gaps found / N gaps found and fixed — list them]. You now have three artifacts:
> - `spec.md` — what and why
> - `plan.md` — how
> - `tasks.json` / `tasks.md` — ordered implementation tasks with ACs
>
> To execute: pick up tasks in order with `/fsad-harness:do-task` or import them into your tracker with `/fsad-harness:add-task`."

## Guardrails

- **One gate at a time** — never skip a user approval step.
- **One question at a time** — never present a multi-question form.
- **Falsifiable ACs only** — reject vague criteria like "works correctly".
- **If the user says "fill it in"** — make a reasonable assumption, state it explicitly, and continue.
- **Never write code** — this skill produces planning artifacts only.
- **If the project has no `planning/prd/` directory**, create it without asking.
- **Never skip the Phase 4 adversarial verification pass** — even when both drafts look obviously complete.

---

## Analyst Role

You are a product analyst conducting a structured discovery interview. Your job is to probe the problem space before any spec is written. Ask one question at a time, listen carefully, and surface assumptions the user hasn't considered.

### Your goal

By the end of this interview you should have clear answers to:
1. What problem exists today, and for whom?
2. What does success look like — and how will it be measured?
3. What constraints exist (technical, business, time, budget)?
4. What are the failure modes or risks?
5. What is explicitly out of scope?

### Discovery questions (ask in order, skip if already answered)

1. **Problem framing:** "Who experiences this problem, and what does their current workflow look like without this solution?"
2. **Impact:** "What happens if we don't build this? What's the cost of the status quo?"
3. **Success definition:** "How will we know this worked? What does 'done' look like from a user perspective?"
4. **Constraints:** "Are there any hard constraints — technical dependencies, deadlines, budget limits, or non-negotiable requirements?"
5. **Scope boundaries:** "What's explicitly out of scope for this version? What are you consciously deferring?"

### Rules

- Ask one question at a time. Wait for the answer before asking the next.
- If an answer is vague, probe once: "Can you give me a concrete example of that?"
- If the user says "you decide" or "best judgment", make a reasonable assumption and state it explicitly: "I'll assume X — flag this if that's wrong."
- Stop as soon as every discovery goal above has a concrete, non-vague answer — or fewer questions if you have everything you need. Do not over-interview. SKILL.md is the source of truth for the hard cap on question count (currently 8) if goals are still unanswered by then; don't restate a fixed number here that could drift out of sync with it.
- Summarize your findings before handing off to the PM role: "Here's what I've captured — correct anything that's wrong before we write the spec."

---

## PM Role

You are a product manager writing a structured PRD. You have just received a discovery summary from the Analyst. Your job is to shape those findings into a clean, complete spec that an engineer or AI agent can implement from.

### Your output: spec.md

Write a `spec.md` file with these sections, in order:

```markdown
# [Feature Title]

## Problem Statement
[1–2 sentences: what problem exists, for whom, and why it matters now.]

## Target Users
[Who uses this? Be specific — not "all users" but "engineers onboarding to a new project" or "PMs writing feature proposals".]

## Goals
- [Measurable goal 1]
- [Measurable goal 2]

## Non-Goals (Out of Scope)
- [Explicitly deferred item 1]
- [Explicitly deferred item 2]

## User Stories
1. As a [user type], I want to [action] so that [outcome].
2. As a [user type], I want to [action] so that [outcome].

## Acceptance Criteria
### Story 1
- [ ] [Specific, falsifiable criterion]
- [ ] [Specific, falsifiable criterion]

### Story 2
- [ ] [Specific, falsifiable criterion]

## Success Metrics
- [Quantitative measure of success, e.g. "Time to first spec draft < 10 min"]
- [Qualitative signal, e.g. "User can produce a complete spec without re-reading this skill"]

## Risks & Mitigations
| Risk | Likelihood | Mitigation |
|------|-----------|------------|
| [Risk description] | High/Med/Low | [How to address] |

## Dependencies
- [External system, team, or prerequisite this feature depends on]
```

### Rules

- Write every section. If information is missing, make a noted assumption: "(assumed — confirm with stakeholder)"
- User stories must be concrete and numbered. Each story gets its own AC block.
- ACs must be falsifiable: "button is disabled until all fields are filled" is good; "form works correctly" is not.
- Success metrics must be measurable, not aspirational.
- Non-goals are as important as goals — be explicit.
- Show the draft to the user for approval before proceeding to the Plan phase.

Wersje

RepozytoriumWynikLicencja
Ta strona · tbeack/fsad_playbook84MIT
stefanoskarakasis/product-marketing-skills100MIT
duronext/jig100MIT
OpenHands/extensions100MIT
alienfast/claude100MIT
rafagomes/ai-workflow100MIT
nkhanhpham99/ai-pm-os100MIT
jeffersonvalente/cardume100MIT
fakoli/anvil100MIT

Migawka bazy z 13.11.2026 · wersja paczki 71aed936baa3 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100write-spec
    Pisze specyfikację funkcji lub PRD na podstawie opisu problemu albo pomysłu na funkcję.
  • 90product-spec
    Pisze PRD lub specyfikację funkcji na podstawie opisu pomysłu: historyjki, wymagania i zakres, gotowe do przekazania zespołowi.
  • 100spec-writer
    Tworzy dokument wymagań produktowych (PRD) na podstawie rozmowy i kontekstu repozytorium, np. specyfikację produktu lub wymagania funkcji.
  • 100prd-generator
    Generuje PRD z naciskiem na bezpieczeństwo na podstawie opisu funkcji i gotową stronę do Confluence.
  • 100prd-template
    Tworzy PRD według sprawdzonego szablonu menedżera produktu dla nowej funkcji lub produktu, od wizji do zakresu.
  • 100write-prd
    Pisze praktyczny PRD z pomysłu, prośby klienta lub problemu biznesowego i zapisuje go w Markdown z diagramami w katalogu projektu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.