- name
SKILL.md
ไฟล์สกิลยังคงอยู่ในรีโพซิทอรีของผู้เผยแพร่
วางคำสั่งที่คัดลอกไว้ในเทอร์มินัล คำสั่งจะติดตั้ง SKILL.md นี้ลงในเอเจนต์ตัวนั้น
npx skills add rizqinrr/viserys-agent --skill get-prd -a cursor -yวางคำสั่งที่คัดลอกไว้ในเทอร์มินัล คำสั่งจะติดตั้ง SKILL.md นี้ลงในเอเจนต์ตัวนั้น
npx skills add rizqinrr/viserys-agent --skill get-prd -a claude-code -yวางคำสั่งที่คัดลอกไว้ในเทอร์มินัล คำสั่งจะติดตั้ง SKILL.md นี้ลงในเอเจนต์ตัวนั้น
npx skills add rizqinrr/viserys-agent --skill get-prd -a codex -yวางคำสั่งที่คัดลอกไว้ในเทอร์มินัล คำสั่งจะติดตั้ง SKILL.md นี้ลงในเอเจนต์ตัวนั้น
npx skills add rizqinrr/viserys-agent --skill get-prd -a grok -yส่งข้อความที่คัดลอกไว้ในแชต Grok Bot แล้ว Bot จะดึง SKILL.md นี้จาก GitHub และเพิ่มลงในสกิลที่ Bot ทุกตัวของคุณใช้ร่วมกัน
Install this skill: https://github.com/rizqinrr/viserys-agent/tree/HEAD/skills/get-prdจากผู้เผยแพร่
get-prd turns a vague request into an approved PRD in one continuous pass. It merges three workflows that are usually run separately:
The reason to merge them is that splitting them loses context. When interviewing is one skill and spec writing is another, the second skill starts cold: it re-asks what the first skill already learned, or it silently assumes answers that were never given. A PRD written from a stale summary is worse than no PRD, because it looks authoritative.
Two consequences of merging, both intentional:
The output is a comprehensive PRD saved to docs/PRD.md (or docs/prd/<name>.md), approved by the user, ready for get-tasks and get-design.
For new users or early-stage concepts, get-prd incorporates idea-refining discovery lenses, non-functional constraint mapping, and core entity/data relationship definitions directly into the document so no separate schema or refinement skills are required.
Use this skill when:
When NOT to use:
get-prd runs in eight phases. Each phase has an exit condition. Do not advance past a phase whose exit condition is unmet.
0. Scope gate -> is this one capability or several?
1. Hypothesis seed -> what do I think they want, and how sure am I?
2. Build the tree -> what decisions exist, and which are on the frontier?
3. Round questions -> ask the frontier, one round at a time
4. Intent probe -> want vs. should-want
5. Restate -> say it back, in their words
6. Gap check -> what does the PRD need that the interview did not produce?
7. Write and gate -> the PRD, then an explicit yes
-> Rekomendasi: ...) so they only need to react rather than brainstorm from scratch.Most requests describe one capability. If this one does, say so in one line and move to Phase 1. This phase exists for the exception.
Detection. Decompose before writing anything when a single request bundles several independently testable capabilities:
When detected, propose a capability map before any interview round. Small and reviewable — a module table plus a build order, not a project plan:
# Capability Map: [Initiative Name]
| Module id | Responsibility | Depends on |
|---|---|---|
| identity | Accounts, sessions, SSO | - |
| billing | Plans, invoices, payments | identity |
| notifications | Email and webhook fan-out | identity |
| reporting | Usage dashboards | billing, notifications |
Build order: identity -> billing, notifications -> reporting
Rules for the map:
billing depends on identity; the contract between them belongs in the provider module's PRD.The map is gated. Ask the user to approve module boundaries, dependency direction, and build order before you interview for any single module. Getting the map wrong is expensive; reviewing ten lines is not.
Then run Phases 1-7 once per module, in build order, each producing its own docs/prd/<module-id>.md. Do not write a monolithic PRD for a multi-module initiative.
Exit condition: either the request is single-capability (say so explicitly), or a capability map is approved.
Before asking anything, write down your current read of the ask and an honest confidence number.
HYPOTHESIS: You want a way to answer "how are we doing?" in standup, and "dashboard" was the convention that came to mind.
CONFIDENCE: ~30% - missing: who it's for, what "metrics" means here, and what success looks like
Rules:
Exit condition: a hypothesis with a confidence number is on the record.
Map the decision space before asking anything. Every decision branches into the decisions that hang off it.
Goal: personal experiment tracker
|
+-- What counts as an experiment? (define the unit)
| |
| +-- What fields describe one? (scope the schema)
|
+-- Where does data come from? (input source)
| |
| +-- Manual entry or import? (interaction model)
|
+-- When is an experiment "done"? (lifecycle)
|
+-- What signal ends it? (success definition)
The frontier is every decision whose prerequisites are already settled: the questions you can ask now without guessing at answers you have not heard yet.
Two rules that make this work:
Facts are your job, never the user's. When a frontier question needs a fact from the environment (filesystem, existing code, a library's API, a config value), dispatch a sub-agent to find it. Do not ask the user for anything you could look up yourself. Do not block the round on it: the exploration is an unsettled prerequisite, so only the questions downstream of it wait. Ask the rest of the frontier now. Decisions are the user's; facts are yours.
Exit condition: the tree is mapped and the first frontier is identified.
Ask the current frontier. Format each question exactly like this:
**Q1 - <question title>**: <question body, possibly multiple paragraphs, often with the candidate options laid out>
-> <your recommended answer, with the reasoning that produced it>
Rules:
Q1, Q2, ... Restart numbering per round.Why the recommendation matters, and its failure mode:
Why one round at a time, not everything at once:
Exit condition: the round's questions are answered and the frontier is recomputed.
The most dangerous answers are the ones where the user says what a thoughtful answer sounds like rather than what they actually want. Watch for:
When you hear any of these, ask:
"If you didn't have to justify this to anyone, what would you actually want?"
That single question often does more work than the previous five. Run it at least once whenever a sophistication-signaling answer appears. Record both the stated answer and the probed answer — the PRD should reflect the second.
Exit condition: at least one probe ran if any sophistication-signaling answer appeared, and the real answer is on the record.
When the tree is nearly settled, write back what you now think the user wants. Keep it tight, use their language, and structure it so they can confirm or correct line by line.
Here's what I now think you want:
- Outcome: <one line>
- User: <one line - who benefits>
- Why now: <one line - what changed>
- Success: <one line - how we know it worked>
- Constraint: <one line - the binding limit>
- Out of scope: <one line - what we are explicitly not doing>
Yes / no / refine?
Rules:
Exit condition: a concrete restate in the user's words is on the record.
You are done interviewing when both of these are true:
If either is false, ask the next round.
There is a floor. If you have run several rounds and the frontier is not shrinking, that is information about the ask, not a reason to keep grinding. Stop and tell the user: "I've asked N rounds and the decision space is not converging. Something foundational is missing. Want to step back?"
The interview produces intent. The PRD needs more than intent. Before writing, compare what you have against the nine mandatory PRD areas.
For each gap, classify it:
Report the gaps as a list, then ask the user whether to resolve them now or record them as Open Questions. Do not silently invent answers. Do not turn this into a second full interview: only the gaps get questioned, one round maximum.
Exit condition: every one of the nine areas is either filled, explicitly asked, or recorded as an open question.
Write the PRD using the template in the next section. Then:
docs/prd/<name>.md. Create docs/prd/ if it does not exist. For a multi-module initiative, one file per module id.get-tasks to break the approved PRD into ordered vertical tasks, and mention get-design before frontend implementation if visual direction or design tokens need definition.Exit condition: the PRD file exists at the agreed path and the user has given an explicit yes.
Fill every section. If a section is genuinely not applicable, write "Not applicable" and a one-line reason — never leave it blank or delete it.
# PRD: [Project or Feature Name]
## Problem Statement
The problem the user is facing, from the user's perspective. Not the technical
symptom — the situation they are in that makes them want this.
## Solution
The solution from the user's perspective. Plain language. No implementation
detail.
## User Stories
A numbered list of user stories covering all aspects of the feature. Each in
the form: As an <actor>, I want a <feature>, so that <benefit>.
1. As a <actor>, I want <feature>, so that <benefit>
2. As a <actor>, I want <feature>, so that <benefit>
Be extensive. A PRD with three user stories usually has not thought about the
feature. Edge cases, failure states, and administrative actions are all stories.
## Objective
What we are building and why. Who the user is. What success looks like in one
or two sentences. This is the anchor every later decision is measured against.
## Technical Decisions
The decisions made during the interview. Include:
- Modules to be built or modified
- Interfaces of those modules that change
- Core architectural style and state flows
- Specific interactions worth pinning down
Do NOT include file paths or code snippets — they go stale fast. Exception: if
a decision is more precisely expressed as a type shape, state machine, or
formula than as prose, inline just that fragment and note it encodes a decision.
## Core Data & Entity Model
The fundamental nouns and entities the product persists, their attributes, and relationships. Defining this here prevents downstream implementation drift:
| Entity | Description | Key Attributes (type, constraints) | Relationships |
|---|---|---|---|
| User | Application account | id (uuid), email (string, unique), role (enum) | 1-to-many Orders |
| ... | ... | ... | ... |
- **Delete Behaviors:** Explicitly note cascade vs. restrict vs. soft delete for core relationships.
- **Constraints & Indexes:** Unique constraints, vital foreign keys, and high-frequency lookup indexes.
## External Integrations & Boundaries
External APIs, SDKs, or services the system interfaces with:
- **Third-Party Services:** Auth providers (OAuth/SSO), payment gateways, email/SMS services, webhooks.
- **Contract Boundary:** Protocol (REST/GraphQL/gRPC), payload formats, failure modes, retry/idempotency expectations.
## Constraints & Non-Functional Requirements
The non-negotiable boundaries and quality standards:
- **Performance & Scale:** Target response times (e.g. p95 < 200ms), concurrency/traffic expectations.
- **Security & Privacy:** Auth/RBAC requirements, sensitive data encryption, GDPR/compliance needs.
- **Technical/Platform Constraints:** Target deployment environment, language/runtime version limits.
- **Accessibility Bar:** WCAG compliance level (e.g. WCAG 2.1 AA) when UI is involved.
## Project Structure
Where source code lives, where tests go, where docs belong. A short tree with
one-line descriptions.
src/ -> Application source
src/lib -> Shared utilities
tests/ -> Unit and integration tests
docs/prd/ -> This PRD and its siblings
## Commands
Full executable commands with flags, not tool names.
Build: <command>
Test: <command>
Lint: <command>
Dev: <command>
## Testing Strategy
What makes a good test here: test external behavior, not implementation
details. Which modules will be tested. Where similar tests already exist
(prior art). Coverage expectations and which test levels cover which concerns.
## Boundaries
- **Always:** <things done on every change - run tests before commit, follow
naming conventions, validate inputs>
- **Ask first:** <things requiring human sign-off - schema changes, new
dependencies, CI config changes>
- **Never:** <hard prohibitions - commit secrets, edit vendor directories,
remove failing tests without approval>
## Out of Scope
Explicitly what is not being built. Silent disagreement about non-goals is half
of misalignment, so state them.
## Success Criteria
Specific, testable conditions that define done.
- [ ] <testable condition>
- [ ] <testable condition>
## Open Questions
Anything unresolved that needs human input before or during implementation.
Before declaring get-prd complete:
docs/prd/<name>.mdget-tasks was made explicitA short before-and-after, condensing a real session.
Without get-prd:
User: build me a dashboard for our metrics
Agent: <starts proposing chart libraries and layouts>
The agent has assumed who it is for, what metrics means, and what success looks like. Every assumption is a place the user can later say "that is not what I meant."
With get-prd:
User: build me a dashboard for our metrics
Agent:
HYPOTHESIS: You want a way to answer "how are we doing?" in standup, and
"dashboard" came to mind because that is the conventional answer.
CONFIDENCE: ~30% - missing: who it is for, what "metrics" are in context, and
what success looks like.
**Q1 - Audience**: When you say "how are we doing?", who is asking - you
alone, the engineering team in standup, or up the chain (manager, exec, board)?
-> Engineering team in standup, because "we" usually scopes that way and
standups are where this question gets asked. If it is for execs, both the
metrics and the framing change a lot.
**Q2 - Data source**: Where do the numbers live today - one tool, or several?
-> Several, which is why a single view is wanted. If it were one tool we would
probably not be having this conversation.
User: Q1: actually it is just for me. Q2: they are spread across different docs.
I keep losing track of which experiments are running.
Agent:
Updated read: not a team dashboard at all. It is a personal experiment
tracker. Confidence: ~60% - still missing: what "experiment" means here and
what a finished one looks like.
**Q1 - Unit definition**: What makes something an experiment rather than a
task or a doc? Is it anything with a hypothesis, or something narrower?
-> Anything you would stop or continue based on a result. That is what makes it
an experiment rather than a chore.
**Q2 - Lifecycle**: When an experiment ends, what happens to it - archive,
delete, or stay visible with a result attached?
-> Stay visible with a result. Deleting history is the mistake that makes
trackers useless after a month.
Ten minutes in, the actual ask turns out to be "a list of experiments with their signals", not "a dashboard". Different artifact, different scope, different work. The dashboard would have been wrong.
The PRD then opens:
# PRD: Experiment Tracker
## Problem Statement
I run several experiments at once and have no single place that says which ones
are running and what their early signal looks like. The information exists but
is spread across different documents, so answering "what am I running?" means
reconstructing it from scratch each time.
## Solution
A personal list that is the single source of truth for running experiments.
Each entry records what the experiment is and what signal it produces, and
finished experiments remain visible with their result attached.
...
get-tasks: downstream and mandatory. The approved PRD is its input. Every task it produces should trace back to a PRD section.get-design: companion and conditional. Use before or alongside frontend task planning when visual direction, design tokens, hierarchy, or anti-AI-slop quality needs definition.Runs a deep structured interview and produces a PRD in a single pass. Use when starting a new application, system, or feature and no requirements document exists yet. Use when the user says "get prd",
---name: get-prddescription: Runs a deep structured interview and produces a PRD in a single pass. Use when starting a new application…---# skills/get-prd/SKILL.mdภาพรวม
Runs a deep structured interview and produces a PRD in a single pass. Use when starting a new application, system, or feature and no requirements document exists yet. Use when the user says "get prd", "bikin PRD", "mau bikin sistem baru", "grill me", or asks to be interviewed toward a spec. Combines design-tree interviewing, intent extraction, capability mapping, and PRD authoring.
FAQ
ดาวน์โหลด skills/get-prd/SKILL.md จากผู้เผยแพร่ หรือคัดลอกพาธแล้วเปิดรีโพซิทอรี PlugMCP แสดงรายการสกิลเท่านั้น ไม่ได้โฮสต์ไฟล์
ผู้เผยแพร่เก็บไว้ที่ https://github.com/rizqinrr/viserys-agent
Claude, Cursor, Codex และ Grok Build อ่าน SKILL.md ที่คุณเพิ่มจากรีโพซิทอรีของผู้เผยแพร่ได้ ส่วน Grok Bot จะติดตั้งให้เมื่อคุณส่งลิงก์โฟลเดอร์ GitHub ของสกิลในแชต
| "Skip the confidence number, it feels arbitrary" | The number is the honesty mechanism. Without it, "I understand" is unfalsifiable. |