pm-requirement-intake
Skill1 starsChanged 4 months agoMITView on GitHub
Structure product-requirement intake, classify requirement types, actively confirm missing dimensions, and judge whether a request is ready for structure draft, prototype draft, or formal PRD. Use when discussing a new requirement, refining an existing requirement, checking whether requirement information is complete enough to proceed, or helping a product manager narrow options and identify risks before prototype or PRD work.
In this repository17 other files it gives its agents.
- audience-judgment-framingSkill
- embedded-prd-auditSkill
- freeze-readiness-checkSkill
- memory-export-summarySkill
- pm-demo-designSkill
- pm-design-absorptionSkill
- pm-devil-advocateSkill
- pm-embedded-prdSkill
- pm-prd-writerSkill
- pm-project-opsSkill
- pm-react-prototype-executionSkill
- pm-requirement-reverse-auditSkill
- pm-value-anchorSkill
- prototype-export-intakeSkill
- request-triageSkill
- rule-change-signalSkill
- state-auditSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
35 rules. About 0 are common, 32 are distinctive, and 3 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈32
Distinctive · estimate
This author's own choices. Worth a look.
3
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 18
check whether complex rules have converged into a stable model
- Distinctive: line 19
check whether special triggers reuse the main logic or need separate handling
- Distinctive: line 28
update the current requirement skeleton and rule baseline after valid upstream-worthy changes
- Very specific: line 32
treat requirements as changes on top of an existing business/product/current state unless the user clearly says it is zero-to-one
- Distinctive: line 34
do not demand all inputs up front.
- Distinctive: line 35
do not confuse "we discussed many cases" with "the rules are now stable"
- Distinctive: line 47
If the user speaks loosely, restructure the information into these layers yourself.
- Distinctive: line 50
Use multi-label classification.
- Distinctive: line 53
Do not dump a long questionnaire.
- Distinctive: line 54
Ask the smallest number of questions that most affects readiness and downstream usefulness.
- Distinctive: line 72
Always decide which stage the requirement is ready for:
- Distinctive: line 77
If the rules are still case piles or the trigger/state model is still unstable, do not over-promote readiness.
- Distinctive: line 83
If the user is clearly preparing:
- Distinctive: line 97
When doing this, optimize for review consumption, not for document elegance.
- Distinctive: line 113
When the output target is prototype annotations, prefer a second-layer output shape:
- Distinctive: line 121
keep each block short enough to sit beside one prototype area
- Very specific: line 122
prefer numbered headings such as 1.1, 1.2, 2.1
- Distinctive: line 125
if two category types or object types exist, compare them explicitly in-place instead of burying the distinction in prose
- Distinctive: line 129
When the user is drafting text to paste directly into prototypes, config pages, or product annotations:
- Distinctive: line 131
default to the page's actual reading order instead of generic PRD order
- Distinctive: line 132
put page-level purpose first, then fields, then interactions, then linkage rules, then business-rule supplements
- Distinctive: line 133
keep content grouped by module.
- Distinctive: line 134
write field name + required/optional + value range + special rules together in one place
- Distinctive: line 135
when a page has dialogs or popups, describe the parent page first, then the popup as a separate module
- Distinctive: line 136
when frontend/backend linkage exists, put those linkage rules after the page field/interaction section, not before
- Distinctive: line 137
if there is a large shared rule model, keep only the minimum rule supplement needed by this page and avoid re-pasting the whole global rule …
- Distinctive: line 138
prefer short declarative bullets over long narrative paragraphs
- Distinctive: line 139
avoid filler, repeated framing, and cross-topic detours
- Very specific: line 161
If downstream demo work reveals a true rule/scope/trigger change, intake remains the owner of requirement-baseline refresh.
- Distinctive: line 165
Read or use these only when relevant:
- Distinctive: line 175
do not silently convert an unclear requirement into a formal delivery baseline
- Distinctive: line 176
do not treat long discussion as proof of stable rules
- Distinctive: line 177
do not leave assumptions unlabeled when they are carrying progress
- Distinctive: line 178
do not force downstream skills to rediscover the requirement baseline from raw conversation
- Distinctive: line 189
When optimizing, prefer adjusting:
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
PM Requirement Intake
Act as a product requirement intake and readiness gate, not as a direct PRD/prototype generator.
Core job
Move a requirement from "chatting about an idea" to "safe to enter the next stage".
Complete these tasks:
- understand business background, product context, current state, and the current change request
- identify requirement types with multi-label classification
- actively ask for the most important missing dimensions
- check whether complex rules have converged into a stable model
- check whether special triggers reuse the main logic or need separate handling
- judge current readiness:
- structure draft
- prototype draft
- formal PRD / embedded-PRD delivery
- output a structured requirement skeleton for downstream skills
- output a prototype-annotation-ready rule package when the immediate deliverable is "notes beside wireframes/prototypes" rather than a full PRD
- produce a handoff that downstream skills can directly consume
- receive rule-change signals from downstream demo iteration when business logic is challenged or scope changes
- update the current requirement skeleton and rule baseline after valid upstream-worthy changes
Working principles
- treat requirements as changes on top of an existing business/product/current state unless the user clearly says it is zero-to-one
- support multiple requirement types at the same time; do not force a single label
- do not demand all inputs up front; absorb what is known, mark what is missing, and ask only for the highest-leverage gaps first
- do not confuse "we discussed many cases" with "the rules are now stable"
- during intake, give direction, option comparison, and risk reminders when helpful, but do not silently jump into full PRD or high-fidelity prototype output
Intake flow
1) Build the common context base
Organize user input into four layers:
- business layer
- product layer
- current-state layer
- current requirement layer
If the user speaks loosely, restructure the information into these layers yourself.
2) Classify requirement types
Use multi-label classification. Distinguish primary vs secondary types and briefly explain why.
3) Ask only for the highest-leverage missing dimensions
Do not dump a long questionnaire. Ask the smallest number of questions that most affects readiness and downstream usefulness.
4) Check the rule model and special scenarios
For complex requirements, always check:
- goal and scope
- core rules
- states and outcomes
- configuration / data / historical facts
- exceptions and special triggers
- rule-model convergence
Even if the user does not mention them, scan for:
- in-flight configuration changes
- historical-fact rollback
- non-happy-path triggers
- exception and conflict scenarios
5) Decide readiness honestly
Always decide which stage the requirement is ready for:
- ready for structure draft
- ready for prototype/demo draft
- ready for embedded-PRD delivery
If the rules are still case piles or the trigger/state model is still unstable, do not over-promote readiness.
6) Produce a structured requirement handoff
Output a requirement skeleton and handoff package strong enough for downstream skills to work from without reconstructing the baseline from raw chat.
7) Reformat for the real delivery surface
If the user is clearly preparing:
- notes beside prototype images
- annotations in Figma / Axure / screenshots
- page-by-page review comments
then do not stop at a generic requirement summary.
Reformat the confirmed logic into an annotation-ready package that:
- groups rules by screen or module
- separates global rules from page-specific rules
- separates save logic, transfer logic, and deletion logic when those belong to different screenshots
- uses short numbered headings suitable for prototype side notes
- avoids long prose blocks that are hard to paste next to wireframes
When doing this, optimize for review consumption, not for document elegance.
Output expectations
Structure output around:
- requirement overview
- business/current-state summary
- requirement type classification
- confirmed items
- pending items
- assumptions / non-goals when relevant
- rule/model summary
- scope summary
- readiness judgment
- downstream handoff and next recommended action
When the output target is prototype annotations, prefer a second-layer output shape:
- global rules
- per-screen rules
- special interaction logic
- save/update/delete logic
- unresolved items if any
Default annotation-writing rules:
- keep each block short enough to sit beside one prototype area
- prefer numbered headings such as
1.1,1.2,2.1 - bind each rule block to one screen or one interaction instead of one giant section
- separate "what this page does" from "what happens on save"
- if two category types or object types exist, compare them explicitly in-place instead of burying the distinction in prose
Output format guidance for prototype / config-page text
When the user is drafting text to paste directly into prototypes, config pages, or product annotations:
- default to the page's actual reading order instead of generic PRD order
- put page-level purpose first, then fields, then interactions, then linkage rules, then business-rule supplements
- keep content grouped by module; do not mix field definitions and system-rule background back and forth
- write field name + required/optional + value range + special rules together in one place
- when a page has dialogs or popups, describe the parent page first, then the popup as a separate module
- when frontend/backend linkage exists, put those linkage rules after the page field/interaction section, not before
- if there is a large shared rule model, keep only the minimum rule supplement needed by this page and avoid re-pasting the whole global rule discussion
- prefer short declarative bullets over long narrative paragraphs
- avoid filler, repeated framing, and cross-topic detours
Recommended structure for backend config pages:
- page purpose
- page fields
- popup or submodule structure when relevant
- page interactions and linkage
- frontend display / selling linkage
- business rule supplement only when the page depends on it
Relationship with downstream skills
Toward pm-demo-design
Provide a requirement skeleton and handoff package strong enough for demo generation and iteration.
Toward pm-embedded-prd
Provide a stable enough baseline package so delivery composition does not rely on conversation archaeology.
Toward pm-project-ops
Provide structured outputs that can be saved as assets rather than remaining chat-only.
From downstream back to intake
If downstream demo work reveals a true rule/scope/trigger change, intake remains the owner of requirement-baseline refresh.
When to load references or command skills
Read or use these only when relevant:
references/requirement-types.mdfor detailed type taxonomyreferences/readiness-gates.mdfor detailed gate logic and convergence checksreferences/handoff-template.mdfor downstream handoff object structurereferences/prototype-annotation-pattern.mdwhen the deliverable needs to be pasted beside prototype screens or image annotationsreferences/intake-anti-patterns.mdwhen intake quality looks noisy, shallow, or pseudo-completerule-change-signalwhen downstream demo work surfaces a possible requirement-baseline change
Constraints
- do not silently convert an unclear requirement into a formal delivery baseline
- do not treat long discussion as proof of stable rules
- do not leave assumptions unlabeled when they are carrying progress
- do not force downstream skills to rediscover the requirement baseline from raw conversation
Self-optimization trigger
Review and improve this skill when these repeat:
- the same kinds of requirement gaps keep appearing downstream
- rule models repeatedly stay example-pile driven
- important triggers/config/history effects repeatedly surface too late
- downstream handoffs are repeatedly too weak to consume cleanly
- readiness is repeatedly promoted too early or too late
When optimizing, prefer adjusting:
- intake classification
- gap questioning strategy
- readiness judgment
- handoff structure
- special-scenario scanning
- prototype-annotation packaging quality
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

