agentleFS
suibianqugenichenghaolesuibianqugenichenghaole/pm-workflow-system/skills/public/pm-requirement-intake/SKILL.md

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.

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
  1. Distinctive:

    check whether complex rules have converged into a stable model

    line 18
  2. Distinctive:

    check whether special triggers reuse the main logic or need separate handling

    line 19
  3. Distinctive:

    update the current requirement skeleton and rule baseline after valid upstream-worthy changes

    line 28
  4. Very specific:

    treat requirements as changes on top of an existing business/product/current state unless the user clearly says it is zero-to-one

    line 32
  5. Distinctive:

    do not demand all inputs up front.

    line 34
  6. Distinctive:

    do not confuse "we discussed many cases" with "the rules are now stable"

    line 35
  7. Distinctive:

    If the user speaks loosely, restructure the information into these layers yourself.

    line 47
  8. Distinctive:

    Use multi-label classification.

    line 50
  9. Distinctive:

    Do not dump a long questionnaire.

    line 53
  10. Distinctive:

    Ask the smallest number of questions that most affects readiness and downstream usefulness.

    line 54
  11. Distinctive:

    Always decide which stage the requirement is ready for:

    line 72
  12. Distinctive:

    If the rules are still case piles or the trigger/state model is still unstable, do not over-promote readiness.

    line 77
  13. Distinctive:

    If the user is clearly preparing:

    line 83
  14. Distinctive:

    When doing this, optimize for review consumption, not for document elegance.

    line 97
  15. Distinctive:

    When the output target is prototype annotations, prefer a second-layer output shape:

    line 113
  16. Distinctive:

    keep each block short enough to sit beside one prototype area

    line 121
  17. Very specific:

    prefer numbered headings such as 1.1, 1.2, 2.1

    line 122
  18. Distinctive:

    if two category types or object types exist, compare them explicitly in-place instead of burying the distinction in prose

    line 125
  19. Distinctive:

    When the user is drafting text to paste directly into prototypes, config pages, or product annotations:

    line 129
  20. Distinctive:

    default to the page's actual reading order instead of generic PRD order

    line 131
  21. Distinctive:

    put page-level purpose first, then fields, then interactions, then linkage rules, then business-rule supplements

    line 132
  22. Distinctive:

    keep content grouped by module.

    line 133
  23. Distinctive:

    write field name + required/optional + value range + special rules together in one place

    line 134
  24. Distinctive:

    when a page has dialogs or popups, describe the parent page first, then the popup as a separate module

    line 135
  25. Distinctive:

    when frontend/backend linkage exists, put those linkage rules after the page field/interaction section, not before

    line 136
  26. Distinctive:

    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 …

    line 137
  27. Distinctive:

    prefer short declarative bullets over long narrative paragraphs

    line 138
  28. Distinctive:

    avoid filler, repeated framing, and cross-topic detours

    line 139
  29. Very specific:

    If downstream demo work reveals a true rule/scope/trigger change, intake remains the owner of requirement-baseline refresh.

    line 161
  30. Distinctive:

    Read or use these only when relevant:

    line 165
  31. Distinctive:

    do not silently convert an unclear requirement into a formal delivery baseline

    line 175
  32. Distinctive:

    do not treat long discussion as proof of stable rules

    line 176
  33. Distinctive:

    do not leave assumptions unlabeled when they are carrying progress

    line 177
  34. Distinctive:

    do not force downstream skills to rediscover the requirement baseline from raw conversation

    line 178
  35. Distinctive:

    When optimizing, prefer adjusting:

    line 189

≈ “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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

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:

  1. business layer
  2. product layer
  3. current-state layer
  4. 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:

  1. requirement overview
  2. business/current-state summary
  3. requirement type classification
  4. confirmed items
  5. pending items
  6. assumptions / non-goals when relevant
  7. rule/model summary
  8. scope summary
  9. readiness judgment
  10. downstream handoff and next recommended action

When the output target is prototype annotations, prefer a second-layer output shape:

  1. global rules
  2. per-screen rules
  3. special interaction logic
  4. save/update/delete logic
  5. 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:

  1. page purpose
  2. page fields
  3. popup or submodule structure when relevant
  4. page interactions and linkage
  5. frontend display / selling linkage
  6. 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.md for detailed type taxonomy
  • references/readiness-gates.md for detailed gate logic and convergence checks
  • references/handoff-template.md for downstream handoff object structure
  • references/prototype-annotation-pattern.md when the deliverable needs to be pasted beside prototype screens or image annotations
  • references/intake-anti-patterns.md when intake quality looks noisy, shallow, or pseudo-complete
  • rule-change-signal when 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:

  1. intake classification
  2. gap questioning strategy
  3. readiness judgment
  4. handoff structure
  5. special-scenario scanning
  6. prototype-annotation packaging quality

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.