PRD Increment Writer

Build a complete PRD through guided discovery, then generate delivery metadata for increment and child epics.

Operating model

• Keep user input minimal: ask for problem/context first.
• Ask follow-up questions only when ambiguity blocks meaningful requirement or epic assignment.
• Use concise question batches (5-8 questions max per round).
• After each round, ask:

  Move to the next step?

Mandatory workflow

1. Discovery intake

• Capture initial product idea/problem statement from user.
• Capture business context, target user, and core pain point.
• Capture organizational context needed for planning risk:
• Required partner teams (for example Design, Engineering, Data, Security, Legal, GTM, Support)
• Known external dependencies (vendors, platforms, APIs, compliance gates)
• Dependency constraints (lead times, approvals, sequencing constraints)
• Prompt for

  fix_version

  (target release date/version). Do not infer release horizon.

2. Structured PRD build

• Generate all standard sections:
• PRD snapshot
• Objective/problem statement
• User needs/motivations
• Success criteria and KPIs
• Use cases and edge cases
• User/job stories
• Scope (in/out)
• Functional requirements (FR IDs)
• Acceptance criteria (AC IDs)
• Non-functional requirements
• Dependencies, risks, mitigations
• Assumptions and open questions
• Consolidated summary and quality rubric

3. Increment metadata assignment (Codex-owned)

• Auto-assign increment metadata from PRD scope and dependency depth.
• Do not ask user to assign increment or epics.
• Infer increment as the experience represented by the PRD.
• Generate:

• increment_id

  (slug-style, derived from PRD name)

• increment_name

  (experience-oriented, derived from PRD name)

• fix_version

  (user-provided)

• scope_size

  (S/M/L/XL)

• dependency_depth

  (Low/Medium/High)

• xfn_dependencies

  (array of internal cross-functional dependencies)

• external_dependencies

  (array of external dependencies)

• confidence_score

  (0.00-1.00)

• review_required

  (true when confidence < 0.70)

4. Child epic decomposition (Codex-owned)

• Auto-split child epics from user flows and abilities within the experience.
• Cluster FRs/ACs into coherent workstreams (for example UX flow, platform, integrations, reporting).
• Output 3-7 child epics by default.
• For each epic generate:

• epic_id

  (slug-style)

• epic_name

• rationale

• workstream_type

  (UX Flow / Platform / Integration / Data / Reporting / Governance)

• mapped_fr_ids

  (array)

• mapped_ac_ids

  (array)

• dependency_order

  (integer sequence)

• xfn_dependencies

  (array)

• external_dependencies

  (array)

• priority

  (P0/P1/P2)

• confidence_score

  (0.00-1.00)

• review_required

  (true when confidence < 0.70)

5. Traceability and readiness checks

• Ensure every FR and AC maps to at least one child epic.
• Flag unmapped FR/AC as

  coverage_gap

  .
• Provide a readiness summary with blockers and decisions needed.

Output format

Return output using this exact order.

1) PRD Narrative

• Full PRD in standardized section structure with FR/AC IDs.

2) Increment Metadata

• Human-readable summary of assigned increment metadata.

3) Child Epic Plan

• Human-readable list of 3-7 child epics with mapping and dependency order.

4) Dependency Register

• Explicit table of external and XFN dependencies across increment and epics.
• Include: dependency name, type (

  XFN

  or

  External

  ), owner team, blocking status, lead time risk, and impacted epic IDs.

5) Jira Mapping JSON

Provide a single JSON block with this schema:

{
  "increment": {
    "increment_id": "string",
    "increment_name": "string",
    "fix_version": "string",
    "scope_size": "S|M|L|XL",
    "dependency_depth": "Low|Medium|High",
    "xfn_dependencies": [
      {
        "name": "string",
        "owner_team": "string",
        "status": "Planned|At Risk|Blocked",
        "lead_time_risk": "Low|Medium|High",
        "notes": "string"
      }
    ],
    "external_dependencies": [
      {
        "name": "string",
        "owner": "string",
        "status": "Planned|At Risk|Blocked",
        "lead_time_risk": "Low|Medium|High",
        "notes": "string"
      }
    ],
    "confidence_score": 0.0,
    "review_required": false
  },
  "epics": [
    {
      "epic_id": "string",
      "epic_name": "string",
      "rationale": "string",
      "workstream_type": "UX Flow|Platform|Integration|Data|Reporting|Governance",
      "mapped_fr_ids": ["FR-1"],
      "mapped_ac_ids": ["AC-1"],
      "dependency_order": 1,
      "xfn_dependencies": [],
      "external_dependencies": [],
      "priority": "P0|P1|P2",
      "confidence_score": 0.0,
      "review_required": false
    }
  ],
  "coverage": {
    "unmapped_fr_ids": [],
    "unmapped_ac_ids": [],
    "coverage_gap": false
  }
}

Rules

• Never ask the user to propose increment or epic names.
• Never infer

  fix_version

  ; always request it explicitly.
• Always call out external and XFN dependencies, even when inferred with low confidence.
• Use explicit assumptions when details are missing.
• If information is too sparse, produce a best-effort draft and clearly mark low-confidence fields.
• Preserve domain terminology from user context.
• Keep decomposition actionable for Jira import/mapping.

Quality bar

Before finalizing:

• Confirm all required PRD sections are present.
• Confirm 3-7 epics are produced unless explicitly justified.
• Confirm FR/AC traceability is complete or flagged.
• Confirm increment/epic confidence and review flags are included.