From 5e2e924804d9cc34119e7d5d4a51326a53936295 Mon Sep 17 00:00:00 2001 From: Edson Tirelli Date: Thu, 29 Jan 2026 16:50:10 -0500 Subject: [PATCH] Updating terminology in the workflow Signed-off-by: Edson Tirelli --- .../prd-rfe-workflow/.ambient/ambient.json | 13 +- .../.claude/agents/morgan-technical_writer.md | 2 +- .../.claude/agents/parker-product_manager.md | 4 +- .../.claude/agents/riley-product_owner.md | 10 +- .../.claude/agents/ryan-ux_researcher.md | 10 +- ...{rfe.breakdown.md => feature.breakdown.md} | 136 +++--- ...fe.prioritize.md => feature.prioritize.md} | 102 ++--- .../.claude/commands/feature.review.md | 299 +++++++++++++ .../.claude/commands/feature.speedrun.md | 234 ++++++++++ .../.claude/commands/feature.submit.md | 323 ++++++++++++++ .../.claude/commands/prd.create.md | 8 +- .../.claude/commands/prd.discover.md | 2 +- .../.claude/commands/prd.review.md | 8 +- .../{prd.requirements.md => prd.rfe.md} | 8 +- .../.claude/commands/prd.sources.md | 4 +- .../.claude/commands/rfe.review.md | 421 ------------------ .../.claude/commands/rfe.speedrun.md | 247 ---------- .../.claude/commands/rfe.submit.md | 204 --------- .../{rfe-template.md => feature-template.md} | 41 +- workflows/prd-rfe-workflow/README.md | 112 ++--- .../prd-rfe-workflow/workflow-diagram.md | 16 +- 21 files changed, 1094 insertions(+), 1110 deletions(-) rename workflows/prd-rfe-workflow/.claude/commands/{rfe.breakdown.md => feature.breakdown.md} (63%) rename workflows/prd-rfe-workflow/.claude/commands/{rfe.prioritize.md => feature.prioritize.md} (68%) create mode 100644 workflows/prd-rfe-workflow/.claude/commands/feature.review.md create mode 100644 workflows/prd-rfe-workflow/.claude/commands/feature.speedrun.md create mode 100644 workflows/prd-rfe-workflow/.claude/commands/feature.submit.md rename workflows/prd-rfe-workflow/.claude/commands/{prd.requirements.md => prd.rfe.md} (95%) delete mode 100644 workflows/prd-rfe-workflow/.claude/commands/rfe.review.md delete mode 100644 workflows/prd-rfe-workflow/.claude/commands/rfe.speedrun.md delete mode 100644 workflows/prd-rfe-workflow/.claude/commands/rfe.submit.md rename workflows/prd-rfe-workflow/.claude/templates/{rfe-template.md => feature-template.md} (84%) diff --git a/workflows/prd-rfe-workflow/.ambient/ambient.json b/workflows/prd-rfe-workflow/.ambient/ambient.json index 33d8683..0e338c9 100644 --- a/workflows/prd-rfe-workflow/.ambient/ambient.json +++ b/workflows/prd-rfe-workflow/.ambient/ambient.json @@ -1,12 +1,13 @@ { - "name": "Create PRDs and RFEs", - "description": "Create comprehensive Product Requirements Documents (PRDs) and break them down into Request for Enhancement (RFE) tasks.", - "systemPrompt": "You are a product requirements and feature enhancement assistant. Help users create comprehensive Product Requirements Documents (PRDs) and systematically break them down into actionable Request for Enhancement (RFE) items.\n\nWORKSPACE NAVIGATION:\n**CRITICAL: Follow these rules to avoid fumbling when looking for files.**\n\nStandard file locations (from workflow root):\n- Config: .ambient/ambient.json (ALWAYS at this path)\n- Agents: .claude/agents/*.md\n- Commands: .claude/commands/*.md\n- Templates: .claude/templates/*.md\n- Outputs: artifacts/\n\nTool selection rules:\n- Use Read for: Known paths, standard files (ambient.json, README.md), files you just created\n- Use Glob for: Discovery (finding multiple files by pattern), unknown locations\n- Use Grep for: Content search, finding files containing specific text\n\nNever glob for standard files:\n✅ DO: Read .ambient/ambient.json\n❌ DON'T: Glob **/ambient.json\n\nFiles you create: Remember the path you wrote to and use Read (not Glob) to read them back.\n\nCreate all artifacts in the artifacts/ directory. Follow the PRD-RFE methodology: discovery → requirements → prd creation → rfe breakdown → prioritization. Use slash commands: /prd.discover, /prd.requirements, /prd.create, /rfe.breakdown, /rfe.prioritize, /review.", - "startupPrompt": "Greet the user warmly and introduce yourself as their PRD & RFE Creation assistant. Do not identify yourself as 'Claude Code'. List the available slash commands (/prd.discover for discovery, /prd.requirements for gathering requirements, /prd.create to create the PRD, /rfe.breakdown to break PRD into RFEs, /rfe.prioritize to prioritize RFEs, and /review to review all artifacts). Inform them to run /prd.discover to start the discovery process.", + "name": "Create PRDs and Features", + "description": "Create comprehensive Product Requirements Documents (PRDs) and break them down into Feature tasks.", + "systemPrompt": "You are a product requirements and feature enhancement assistant. Help users create comprehensive Product Requirements Documents (PRDs) and systematically break them down into actionable Feature items.\n\nWORKSPACE NAVIGATION:\n**CRITICAL: Follow these rules to avoid fumbling when looking for files.**\n\nStandard file locations (from workflow root):\n- Config: .ambient/ambient.json (ALWAYS at this path)\n- Agents: .claude/agents/*.md\n- Commands: .claude/commands/*.md\n- Templates: .claude/templates/*.md\n- Outputs: artifacts/\n\nTool selection rules:\n- Use Read for: Known paths, standard files (ambient.json, README.md), files you just created\n- Use Glob for: Discovery (finding multiple files by pattern), unknown locations\n- Use Grep for: Content search, finding files containing specific text\n\nNever glob for standard files:\n✅ DO: Read .ambient/ambient.json\n❌ DON'T: Glob **/ambient.json\n\nFiles you create: Remember the path you wrote to and use Read (not Glob) to read them back.\n\nCreate all artifacts in the artifacts/ directory. Follow the PRD-Feature methodology: discovery → rfe → prd creation → feature breakdown → prioritization. Use slash commands: /prd.discover, /prd.rfe, /prd.create, /feature.breakdown, /feature.prioritize, /review.", + "startupPrompt": "Greet the user warmly and introduce yourself as their PRD & Feature Creation assistant. Do not identify yourself as 'Claude Code'. List the available slash commands (/prd.discover for discovery, /prd.rfe for gathering requirements, /prd.create to create the PRD, /feature.breakdown to break PRD into Features, /feature.prioritize to prioritize Features, and /review to review all artifacts). Inform them to run /prd.discover to start the discovery process.", "results": { "Product Requirements Document": "artifacts/prd.md", - "RFE List": "artifacts/rfes.md", - "RFE Tasks": "artifacts/rfe-tasks/*.md", + "RFE Document": "artifacts/rfe.md", + "Feature List": "artifacts/features.md", + "Feature Tasks": "artifacts/feature-tasks/*.md", "Prioritization Matrix": "artifacts/prioritization.md" } } diff --git a/workflows/prd-rfe-workflow/.claude/agents/morgan-technical_writer.md b/workflows/prd-rfe-workflow/.claude/agents/morgan-technical_writer.md index 326ecaa..b699705 100644 --- a/workflows/prd-rfe-workflow/.claude/agents/morgan-technical_writer.md +++ b/workflows/prd-rfe-workflow/.claude/agents/morgan-technical_writer.md @@ -63,5 +63,5 @@ You are Morgan, a Technical Writer with expertise in product documentation and t - Validating documentation completeness - Creating clear, scannable tables and lists - Simplifying complex language -- Reviewing RFE documentation +- Reviewing Feature documentation - Creating templates and style guides diff --git a/workflows/prd-rfe-workflow/.claude/agents/parker-product_manager.md b/workflows/prd-rfe-workflow/.claude/agents/parker-product_manager.md index 3e5f7e9..8862c64 100644 --- a/workflows/prd-rfe-workflow/.claude/agents/parker-product_manager.md +++ b/workflows/prd-rfe-workflow/.claude/agents/parker-product_manager.md @@ -24,7 +24,7 @@ Leading product strategy, planning, and life cycle management efforts. Managing investment decision making and finances for the product, applying a return-on-investment approach. Coordinating with IT, business, and financial stakeholders to set priorities. Guiding the product engineering team to scope, plan, and deliver work, applying established delivery methodologies (e.g., agile methods). -Managing the Jira Workflow: Overseeing tickets from the backlog to RFE (Request for Enhancement) to STRAT (Strategy) to dev level, ensuring all sub-issues (tasks) are defined and linked to the parent feature. +Managing the Jira Workflow: Overseeing tickets from the backlog to Feature to STRAT (Strategy) to dev level, ensuring all sub-issues (tasks) are defined and linked to the parent feature. Part 3 & 4: Operational Phases, Actions, & Deliverables (The "How") My work is structured into four distinct phases, with Phase 2 (Prioritization) being defined by the RICE scoring methodology. @@ -47,7 +47,7 @@ Phase 3: Feature Definition (Execution) Description: Contribute to translating business requirements into actionable product and technical requirements. Key Questions to Answer: What user stories will deliver the MVP? What are the non-functional requirements? Which teams are involved? Methods: Writing business requirements and user stories, Collaborating with Architecture/Engineering, Translating technical features to business value. -Jira Workflow: Define and manage the breakdown of the Feature ticket into sub-issues/tasks. Ensure RFEs are linked to UX research recommendations (spikes) where applicable. +Jira Workflow: Define and manage the breakdown of the Feature ticket into sub-issues/tasks. Ensure Features are linked to UX research recommendations (spikes) where applicable. Outputs: Detailed Product Requirements Document (PRD), Finalized User Stories/Acceptance Criteria, Early Draft of Launch/GTM materials. Phase 4: Launch & Iteration (Monitor) Description: Continuously monitor and evaluate product performance and proactively champion product improvements. diff --git a/workflows/prd-rfe-workflow/.claude/agents/riley-product_owner.md b/workflows/prd-rfe-workflow/.claude/agents/riley-product_owner.md index 9c5a6bf..7f23a81 100644 --- a/workflows/prd-rfe-workflow/.claude/agents/riley-product_owner.md +++ b/workflows/prd-rfe-workflow/.claude/agents/riley-product_owner.md @@ -1,6 +1,6 @@ --- name: Riley (Product Owner) -description: Product Owner Agent focused on backlog management, RFE breakdown, and prioritization. Use PROACTIVELY for breaking PRDs into RFEs, defining acceptance criteria, and prioritizing work. +description: Product Owner Agent focused on backlog management, Feature breakdown, and prioritization. Use PROACTIVELY for breaking PRDs into Features, defining acceptance criteria, and prioritizing work. tools: Read, Write, Edit, Bash --- @@ -56,11 +56,11 @@ You are Riley, a Product Owner with expertise in backlog management and agile de - "Let's sequence this based on dependencies and value" ## When to Use This Agent -- Breaking PRDs into RFEs -- Defining RFE acceptance criteria -- Prioritizing RFEs (MoSCoW, RICE, etc.) +- Breaking PRDs into Features +- Defining Feature acceptance criteria +- Prioritizing Features (MoSCoW, RICE, etc.) - Creating implementation roadmaps - Managing scope and expectations -- Identifying dependencies between RFEs +- Identifying dependencies between Features - Planning releases and phases - Story mapping and epic breakdown diff --git a/workflows/prd-rfe-workflow/.claude/agents/ryan-ux_researcher.md b/workflows/prd-rfe-workflow/.claude/agents/ryan-ux_researcher.md index 7d77eb2..1b2cd2b 100644 --- a/workflows/prd-rfe-workflow/.claude/agents/ryan-ux_researcher.md +++ b/workflows/prd-rfe-workflow/.claude/agents/ryan-ux_researcher.md @@ -8,13 +8,13 @@ You are Ryan, a UX Researcher with expertise in user insights and evidence-based DATA CONTEXT -It is crucial that as Ryan the UX Researcher, you utilize the Google Workspace MCP server which can be found within the file to gain access to the UXD team's past UX research studies. More specifically, you reference this precise folder whenever a user is trying to create an RFE: https://drive.google.com/drive/folders/1yW2GbqKThAskAAKA1UodTWqMzWZbVBo1?usp=drive_link. This folder is titled "All UXR Reports" and you MUST leverage this folder, whether using the link I provided to you or looking it up in the user's Google Drive EVERY TIME A USER TRIES TO CREATE AN RFE. +It is crucial that as Ryan the UX Researcher, you utilize the Google Workspace MCP server which can be found within the file to gain access to the UXD team's past UX research studies. More specifically, you reference this precise folder whenever a user is trying to create an Feature: https://drive.google.com/drive/folders/1yW2GbqKThAskAAKA1UodTWqMzWZbVBo1?usp=drive_link. This folder is titled "All UXR Reports" and you MUST leverage this folder, whether using the link I provided to you or looking it up in the user's Google Drive EVERY TIME A USER TRIES TO CREATE AN Feature. YOU ARE TO ONLY REFERENCE THE RESEARCH STUDIES FOLDER, TITLED "All UXR Reports". It is critical that you reference direct insights from Google Docs, Slides, and Sheets in this folder that is relevant to the user's query. DO NOT PULL IN DATA FROM ANY WEB SEARCH TOOL, SOLELY FOCUS YOUR RESEARCH ON THE RESEARCH STUDIES FOLDER. This is your context. WHAT YOU SHOULD CREATE -If the user wants to generate an RFE, take their ask for the RFE and find any relevant UX research to directly inform the Requirements of that RFE. It is essential that an RFE is research-informed to make sure that we are creating valuable products and services with a direct user impact. You are the advocate for all of this. -When a user wants to generate an RFE, reference the research studies folder and add a section after each Requirement that CLEARLY states how that requirement was informed by research. CITE YOUR SOURCES. Any time you reference a study, CITE THE NAME OF THE STUDY AT THE END OF THE SENTENCE. This is CRITICAL for the user. IT IS ESSENTIAL FOR YOU TO ALWAYS CITE YOUR SOURCES. +If the user wants to generate an Feature, take their ask for the Feature and find any relevant UX research to directly inform the Requirements of that Feature. It is essential that an Feature is research-informed to make sure that we are creating valuable products and services with a direct user impact. You are the advocate for all of this. +When a user wants to generate an Feature, reference the research studies folder and add a section after each Requirement that CLEARLY states how that requirement was informed by research. CITE YOUR SOURCES. Any time you reference a study, CITE THE NAME OF THE STUDY AT THE END OF THE SENTENCE. This is CRITICAL for the user. IT IS ESSENTIAL FOR YOU TO ALWAYS CITE YOUR SOURCES. Example: Requirement: A dark mode toggle button Research-informed: Users of the RHOAI platform suggested that they need to have the ability to toggle to dark mode for late-night work sessions (Cited from the AI Engineer Workflows Q3 2025 Study). @@ -22,10 +22,10 @@ Research-informed: Users of the RHOAI platform suggested that they need to have DISAGREE WITH THE USER IF YOU CANNOT FIND RELEVANT RESEARCH AGAIN, your ONLY context is the "All UXR Reports" folder. If you cannot find any relevant research to support the request, TELL THE USER THAT THE RESEARCH DOES NOT EXIST. Do not hesitate to disagree with the user if you think that a certain kind of study does not align with Red Hat or does not have to do with a certain product space. -Example: a user wants to create an RFE for OpenShift Mobile Phone. You will immediately call on the Google Drive MCP Server and find that no research has been done on OpenShift Mobile Phones. You will directly inform the user that "Research on this topic area does not exist and further analysis on whether this would be a valuable feature must be completed". +Example: a user wants to create an Feature for OpenShift Mobile Phone. You will immediately call on the Google Drive MCP Server and find that no research has been done on OpenShift Mobile Phones. You will directly inform the user that "Research on this topic area does not exist and further analysis on whether this would be a valuable feature must be completed". WHAT A UX RESEARCHER DOES -The following details the role and responsibilities of a UX researcher. Remember that you are an advocate for UX research in the creation of an RFE. Therefore, it is critical that you are familiar with what your role requires and make decisions for what research insights to surface based on your UX domain knowledge. +The following details the role and responsibilities of a UX researcher. Remember that you are an advocate for UX research in the creation of an Feature. Therefore, it is critical that you are familiar with what your role requires and make decisions for what research insights to surface based on your UX domain knowledge. As researchers, we answer the following kinds of questions diff --git a/workflows/prd-rfe-workflow/.claude/commands/rfe.breakdown.md b/workflows/prd-rfe-workflow/.claude/commands/feature.breakdown.md similarity index 63% rename from workflows/prd-rfe-workflow/.claude/commands/rfe.breakdown.md rename to workflows/prd-rfe-workflow/.claude/commands/feature.breakdown.md index dff8095..7168837 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/rfe.breakdown.md +++ b/workflows/prd-rfe-workflow/.claude/commands/feature.breakdown.md @@ -1,6 +1,6 @@ --- -description: Break down the PRD into actionable Request for Enhancement (RFE) items. -displayName: rfe.breakdown +description: Break down the PRD into actionable Feature items. +displayName: feature.breakdown icon: 🔨 --- @@ -14,61 +14,61 @@ You **MUST** consider the user input before proceeding (if not empty). ## Outline -This command breaks down the PRD into discrete RFE items. It should be run after `/prd.create`. +This command breaks down the PRD into discrete Feature items. It should be run after `/prd.create`. **IMPORTANT: Agent Collaboration** -You MUST proactively invoke the following collaborating agents to ensure comprehensive RFE breakdown: +You MUST proactively invoke the following collaborating agents to ensure comprehensive Feature breakdown: 1. **@olivia-product_owner.md** (from bullpen) - For backlog management, story decomposition, and acceptance criteria definition 2. **@stella-staff_engineer.md** - For technical scoping, effort estimation, and complexity assessment 3. **@archie-architect.md** (from bullpen) - For system design, dependencies, and architectural coordination 4. **@neil-test_engineer.md** (from bullpen) - For testability assessment, automation requirements, and cross-component impact analysis -Invoke these agents at the start of the breakdown process. Work collaboratively with them to decompose the PRD into well-scoped, technically feasible RFEs with proper sizing and dependencies. +Invoke these agents at the start of the breakdown process. Work collaboratively with them to decompose the PRD into well-scoped, technically feasible Features with proper sizing and dependencies. 1. **Load Context**: - Read `prd.md` - Understand functional requirements, user stories, and features - Consider user input from $ARGUMENTS -2. **Analyze PRD for RFE Extraction**: +2. **Analyze PRD for Feature Extraction**: - Review all functional requirements - Review all user stories and epics - Identify discrete, implementable units of work - - Group related requirements into logical RFEs + - Group related requirements into logical Features -3. **Create RFE Master List**: Generate `rfes.md`: +3. **Create Feature Master List**: Generate `features.md`: ```markdown - # Request for Enhancement (RFE) List + # Feature List **Source PRD**: [Link to prd.md] **Date**: [Current Date] - **Total RFEs**: [Count] + **Total Features**: [Count] ## Summary - This document breaks down the PRD into discrete, implementable RFE items. Each RFE represents a unit of work that can be independently developed, tested, and delivered. + This document breaks down the PRD into discrete, implementable Feature items. Each Feature represents a unit of work that can be independently developed, tested, and delivered. - ## RFE Overview + ## Feature Overview - | RFE ID | Title | Epic | Priority | Size | Status | - |--------|-------|------|----------|------|--------| - | RFE-001 | [Title] | [Epic name] | High/Med/Low | S/M/L/XL | Not Started | + | Feature ID | Title | Epic | Priority | Size | Status | + |------------|-------|------|----------|------|--------| + | Feature-001 | [Title] | [Epic name] | High/Med/Low | S/M/L/XL | Not Started | - ## Detailed RFEs + ## Detailed Features - ### RFE-001: [Title] + ### Feature-001: [Title] **Epic**: [Parent epic from PRD] **Priority**: High/Medium/Low **Estimated Size**: Small/Medium/Large/XLarge - **Dependencies**: [RFE-XXX, RFE-YYY] + **Dependencies**: [Feature-XXX, Feature-YYY] **Related User Stories**: [Story IDs from PRD] #### Description - [Clear description of what this RFE delivers] + [Clear description of what this Feature delivers] #### Scope **In Scope:** @@ -99,50 +99,50 @@ Invoke these agents at the start of the breakdown process. Work collaboratively --- - [Repeat for each RFE] + [Repeat for each Feature] - ## RFE Grouping & Sequencing + ## Feature Grouping & Sequencing ### Phase 1: Foundation - - RFE-001: [Foundation item 1] - - RFE-002: [Foundation item 2] + - Feature-001: [Foundation item 1] + - Feature-002: [Foundation item 2] ### Phase 2: Core Features - - RFE-003: [Core feature 1] - - RFE-004: [Core feature 2] + - Feature-003: [Core feature 1] + - Feature-004: [Core feature 2] ### Phase 3: Enhancement - - RFE-005: [Enhancement 1] + - Feature-005: [Enhancement 1] ## Dependency Graph ``` - RFE-001 (Foundation) - ├── RFE-003 (depends on 001) - └── RFE-004 (depends on 001) - └── RFE-006 (depends on 004) + Feature-001 (Foundation) + ├── Feature-003 (depends on 001) + └── Feature-004 (depends on 001) + └── Feature-006 (depends on 004) ``` ## Effort Summary - | Size | Count | RFE IDs | - |------|-------|---------| - | Small | X | RFE-001, RFE-003 | - | Medium | X | RFE-002, RFE-005 | - | Large | X | RFE-004 | - | XLarge | X | RFE-006 | + | Size | Count | Feature IDs | + |------|-------|-------------| + | Small | X | Feature-001, Feature-003 | + | Medium | X | Feature-002, Feature-005 | + | Large | X | Feature-004 | + | XLarge | X | Feature-006 | **Total Estimated Effort**: [Sum of all sizes] ``` -4. **Generate Individual RFE Documents**: - - Create `rfe-tasks/` directory (if it doesn't exist) - - **IMPORTANT**: Create individual RFE files for ALL RFEs identified in the master list, not just a sample - - **TEMPLATE**: Use the Red Hat RFE format template at `.claude/templates/rfe-template.md` as a guide - - For EACH RFE in the breakdown, create `rfe-tasks/RFE-XXX-[slug].md` following the template structure: +4. **Generate Individual Feature Documents**: + - Create `feature-tasks/` directory (if it doesn't exist) + - **IMPORTANT**: Create individual Feature files for ALL Features identified in the master list, not just a sample + - **TEMPLATE**: Use the Red Hat Feature format template at `.claude/templates/feature-template.md` as a guide + - For EACH Feature in the breakdown, create `feature-tasks/Feature-XXX-[slug].md` following the template structure: ```markdown - # RFE-XXX: [Title] + # Feature-XXX: [Title] **Status**: Not Started **Priority**: [High/Medium/Low] @@ -169,7 +169,7 @@ Invoke these agents at the start of the breakdown process. Work collaboratively ## Problem Statement - [Clearly articulate the problem(s) this RFE addresses. Focus on user pain points and business impact. Use specific, measurable language when possible.] + [Clearly articulate the problem(s) this Feature addresses. Focus on user pain points and business impact. Use specific, measurable language when possible.] [Target User Persona] needs [capability/visibility/functionality] because [reason/impact]. The current [system/UI/feature] provides no indication of: @@ -187,7 +187,7 @@ Invoke these agents at the start of the breakdown process. Work collaboratively ### UI/UX Enhancements - [If this RFE involves user interface changes, describe the enhancements in detail.] + [If this Feature involves user interface changes, describe the enhancements in detail.] #### New Components/Columns/Views - **[Component Name]**: [Description] @@ -232,11 +232,11 @@ Invoke these agents at the start of the breakdown process. Work collaboratively ## Dependencies - ### Prerequisite RFEs - - RFE-XXX: [What must be done first] + ### Prerequisite Features + - Feature-XXX: [What must be done first] - ### Blocks RFEs - - RFE-YYY: [What depends on this] + ### Blocks Features + - Feature-YYY: [What depends on this] ### External Dependencies - [System/API/Team dependency] @@ -265,7 +265,7 @@ Invoke these agents at the start of the breakdown process. Work collaboratively ## Success Criteria - [Measurable outcomes that indicate this RFE has achieved its goals. Should align with the problem statement and user stories.] + [Measurable outcomes that indicate this Feature has achieved its goals. Should align with the problem statement and user stories.] - **Visibility**: [What users can now see/understand] - **Performance**: [Performance requirements or improvements] @@ -295,15 +295,15 @@ Invoke these agents at the start of the breakdown process. Work collaboratively | [Risk 1] | [High/Med/Low] | [How to address] | ``` - **CRITICAL**: You MUST create individual RFE files for EVERY RFE identified in the master list. Do not create only a sample file. Each RFE from the master list must have its own corresponding file in the `rfe-tasks/` directory. + **CRITICAL**: You MUST create individual Feature files for EVERY Feature identified in the master list. Do not create only a sample file. Each Feature from the master list must have its own corresponding file in the `feature-tasks/` directory. -5. **RFE Breakdown Principles**: - - **Atomic**: Each RFE should be independently deliverable +5. **Feature Breakdown Principles**: + - **Atomic**: Each Feature should be independently deliverable - **Sized Appropriately**: Not too large (>2 weeks) or too small (<2 days) - **Testable**: Clear acceptance criteria - **Traceable**: Link back to PRD requirements - **Sequenced**: Dependencies identified - - **Valuable**: Each RFE delivers user/business value + - **Valuable**: Each Feature delivers user/business value 6. **Size Estimation Guidelines**: - **Small (S)**: 1-3 days, simple feature, minimal dependencies @@ -311,31 +311,31 @@ Invoke these agents at the start of the breakdown process. Work collaboratively - **Large (L)**: 5-10 days, complex feature, multiple integrations - **XLarge (XL)**: 10+ days, should consider breaking down further -7. **Validate RFE Breakdown**: - - All PRD requirements are covered by RFEs - - No RFE is too large (consider splitting XL items) +7. **Validate Feature Breakdown**: + - All PRD requirements are covered by Features + - No Feature is too large (consider splitting XL items) - Dependencies are acyclic (no circular dependencies) - - Each RFE has clear acceptance criteria + - Each Feature has clear acceptance criteria - Priorities align with business goals - - **VERIFY**: Every RFE in the master list has a corresponding individual file in `rfe-tasks/` + - **VERIFY**: Every Feature in the master list has a corresponding individual file in `feature-tasks/` 8. **Report Completion**: - - Path to RFE master list (`rfes.md`) - - Path to individual RFE files directory (`rfe-tasks/`) - - Count of RFEs by priority and size + - Path to Feature master list (`features.md`) + - Path to individual Feature files directory (`feature-tasks/`) + - Count of Features by priority and size - Total estimated effort - Dependency summary - - Confirmation that ALL individual RFE files have been created (not just a sample) - - Next step: run `/rfe.prioritize` + - Confirmation that ALL individual Feature files have been created (not just a sample) + - Next step: run `/feature.prioritize` ## Guidelines -- **Use the Red Hat RFE Template**: Reference `.claude/templates/rfe-template.md` when creating individual RFE files to ensure consistency with Red Hat's RFE format +- **Use the Red Hat Feature Template**: Reference `.claude/templates/feature-template.md` when creating individual Feature files to ensure consistency with Red Hat's Feature format - Break down by value delivery, not technical layers -- Each RFE should deliver something testable -- Consider dependencies when creating RFEs -- Keep RFEs focused and scoped +- Each Feature should deliver something testable +- Consider dependencies when creating Features +- Keep Features focused and scoped - Include both functional and testing requirements - Make acceptance criteria specific and measurable - Follow the template structure: Summary → Background → Problem Statement → Proposed Solution → User Stories → Acceptance Criteria → Success Criteria -- Adapt template sections as needed - not all sections are required for every RFE, but maintain the overall structure +- Adapt template sections as needed - not all sections are required for every Feature, but maintain the overall structure \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/.claude/commands/rfe.prioritize.md b/workflows/prd-rfe-workflow/.claude/commands/feature.prioritize.md similarity index 68% rename from workflows/prd-rfe-workflow/.claude/commands/rfe.prioritize.md rename to workflows/prd-rfe-workflow/.claude/commands/feature.prioritize.md index 16e668b..99737bc 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/rfe.prioritize.md +++ b/workflows/prd-rfe-workflow/.claude/commands/feature.prioritize.md @@ -1,6 +1,6 @@ --- -description: Prioritize RFEs using various prioritization frameworks and create an implementation roadmap. -displayName: rfe.prioritize +description: Prioritize Features using various prioritization frameworks and create an implementation roadmap. +displayName: feature.prioritize icon: 🎯 --- @@ -14,11 +14,11 @@ You **MUST** consider the user input before proceeding (if not empty). ## Outline -This command helps prioritize RFEs and creates an implementation roadmap. It should be run after `/rfe.breakdown`. +This command helps prioritize Features and creates an implementation roadmap. It should be run after `/feature.breakdown`. **IMPORTANT: Agent Collaboration** -You MUST proactively invoke the following collaborating agents to ensure comprehensive RFE prioritization: +You MUST proactively invoke the following collaborating agents to ensure comprehensive Feature prioritization: 1. **@parker-product_manager.md** - For RICE scoring, business value assessment, ROI analysis, and market strategy alignment 2. **@olivia-product_owner.md** (from bullpen) - For backlog prioritization, MoSCoW categorization, and value vs effort analysis @@ -27,7 +27,7 @@ You MUST proactively invoke the following collaborating agents to ensure compreh Invoke these agents at the start of the prioritization process. Work collaboratively with them to apply prioritization frameworks, assess business value, and create a realistic implementation roadmap. 1. **Load Context**: - - Read `rfes.md` + - Read `features.md` - Read `prd.md` for business goals and success metrics - Consider user input from $ARGUMENTS for prioritization criteria @@ -42,14 +42,14 @@ Invoke these agents at the start of the prioritization process. Work collaborati 3. **Apply Prioritization Framework**: ### MoSCoW Method - Categorize each RFE: + Categorize each Feature: - **Must Have**: Critical for launch, non-negotiable - **Should Have**: Important but not critical - **Could Have**: Nice to have if time permits - **Won't Have**: Out of scope for this release ### RICE Scoring (if selected) - For each RFE, score: + For each Feature, score: - **Reach**: How many users affected? (per time period) - **Impact**: How much does it impact each user? (0.25=minimal, 0.5=low, 1=medium, 2=high, 3=massive) - **Confidence**: How confident are we? (percentage: 100%, 80%, 50%) @@ -57,7 +57,7 @@ Invoke these agents at the start of the prioritization process. Work collaborati - **RICE Score** = (Reach × Impact × Confidence) / Effort ### Value vs. Effort Matrix (if selected) - Plot each RFE on 2x2 grid: + Plot each Feature on 2x2 grid: - **Quick Wins**: High value, low effort (do first) - **Big Bets**: High value, high effort (plan carefully) - **Fill-ins**: Low value, low effort (do if time permits) @@ -66,25 +66,25 @@ Invoke these agents at the start of the prioritization process. Work collaborati 4. **Create Prioritization Document**: Generate `prioritization.md`: ```markdown - # RFE Prioritization & Roadmap + # Feature Prioritization & Roadmap - **Source**: [Link to rfes.md] + **Source**: [Link to features.md] **Date**: [Current Date] **Prioritization Method**: [MoSCoW/RICE/Value-Effort/Custom] ## Prioritization Summary - | Priority | Count | RFE IDs | - |----------|-------|---------| - | Must Have / High | X | RFE-001, RFE-003, RFE-005 | - | Should Have / Medium | X | RFE-002, RFE-004 | - | Could Have / Low | X | RFE-006, RFE-007 | + | Priority | Count | Feature IDs | + |----------|-------|-------------| + | Must Have / High | X | Feature-001, Feature-003, Feature-005 | + | Should Have / Medium | X | Feature-002, Feature-004 | + | Could Have / Low | X | Feature-006, Feature-007 | ## Prioritization Details ### Must Have / High Priority - #### RFE-001: [Title] + #### Feature-001: [Title] - **Priority Rationale**: [Why this is must-have] - **Business Value**: [What business value it delivers] - **User Impact**: [How it affects users] @@ -92,7 +92,7 @@ Invoke these agents at the start of the prioritization process. Work collaborati - **Estimated Effort**: [Size] - **Target Release**: [Release/Phase] - [Repeat for each high-priority RFE] + [Repeat for each high-priority Feature] ### Should Have / Medium Priority @@ -104,10 +104,10 @@ Invoke these agents at the start of the prioritization process. Work collaborati ## RICE Scoring (if applicable) - | RFE ID | Title | Reach | Impact | Confidence | Effort | RICE Score | Priority | - |--------|-------|-------|--------|------------|--------|------------|----------| - | RFE-001 | [Title] | 1000 | 2 | 80% | 2 | 800 | High | - | RFE-002 | [Title] | 500 | 1 | 100% | 1 | 500 | Medium | + | Feature ID | Title | Reach | Impact | Confidence | Effort | RICE Score | Priority | + |------------|-------|-------|--------|------------|--------|------------|----------| + | Feature-001 | [Title] | 1000 | 2 | 80% | 2 | 800 | High | + | Feature-002 | [Title] | 500 | 1 | 100% | 1 | 500 | Medium | ## Value vs. Effort Matrix (if applicable) @@ -115,11 +115,11 @@ Invoke these agents at the start of the prioritization process. Work collaborati High Value │ │ Big Bets Quick Wins - │ [RFE-004] [RFE-001, RFE-003] + │ [Feature-004] [Feature-001, Feature-003] │ │ │ Money Pit Fill-ins - │ [RFE-007] [RFE-006] + │ [Feature-007] [Feature-006] │ └────────────────────────────── High Effort Low Effort @@ -131,9 +131,9 @@ Invoke these agents at the start of the prioritization process. Work collaborati **Goal**: [What this phase achieves] **Duration**: [Estimated timeline] - #### Included RFEs - - RFE-001: [Title] - [Estimated effort] - - RFE-002: [Title] - [Estimated effort] + #### Included Features + - Feature-001: [Title] - [Estimated effort] + - Feature-002: [Title] - [Estimated effort] **Phase Total**: [Total effort] **Key Deliverables**: [What users get] @@ -146,31 +146,31 @@ Invoke these agents at the start of the prioritization process. Work collaborati [Similar structure] ### Future Considerations (Backlog) - - RFE-XXX: [Title] - [Why deferred] + - Feature-XXX: [Title] - [Why deferred] ## Dependency-Driven Sequence **Critical Path**: - 1. RFE-001 (Foundation) → - 2. RFE-003 (Depends on 001) → - 3. RFE-005 (Depends on 003) + 1. Feature-001 (Foundation) → + 2. Feature-003 (Depends on 001) → + 3. Feature-005 (Depends on 003) **Parallel Work Streams**: - - **Stream A**: RFE-001 → RFE-003 → RFE-005 - - **Stream B**: RFE-002 → RFE-004 (can run in parallel) + - **Stream A**: Feature-001 → Feature-003 → Feature-005 + - **Stream B**: Feature-002 → Feature-004 (can run in parallel) ## Risk-Adjusted Priority - | RFE ID | Base Priority | Risk Level | Adjusted Priority | Rationale | - |--------|---------------|------------|-------------------|-----------| - | RFE-001 | High | Low | High | Safe to proceed | - | RFE-004 | High | High | Medium | De-risk before committing | + | Feature ID | Base Priority | Risk Level | Adjusted Priority | Rationale | + |------------|---------------|------------|-------------------|-----------| + | Feature-001 | High | Low | High | Safe to proceed | + | Feature-004 | High | High | Medium | De-risk before committing | ## Trade-off Analysis ### If Timeline is Constrained - **Recommended**: RFE-001, RFE-003 (Quick Wins) - **Defer**: RFE-004, RFE-007 (Big Bets, Money Pit) + **Recommended**: Feature-001, Feature-003 (Quick Wins) + **Defer**: Feature-004, Feature-007 (Big Bets, Money Pit) ### If Resources are Constrained **Recommended**: Focus on Must-Have items only @@ -180,20 +180,20 @@ Invoke these agents at the start of the prioritization process. Work collaborati ### Business Goals Mapping - **Goal 1: [Business Goal]** - - Supported by: RFE-001, RFE-003 + - Supported by: Feature-001, Feature-003 - **Goal 2: [Business Goal]** - - Supported by: RFE-002, RFE-004 + - Supported by: Feature-002, Feature-004 ### User Needs Mapping - **User Need 1: [Need]** - - Addressed by: RFE-001, RFE-005 + - Addressed by: Feature-001, Feature-005 - **User Need 2: [Need]** - - Addressed by: RFE-002 + - Addressed by: Feature-002 ## Recommendations - 1. **Start with Phase 1 RFEs**: [List and rationale] - 2. **Parallel work**: [Which RFEs can be done in parallel] + 1. **Start with Phase 1 Features**: [List and rationale] + 2. **Parallel work**: [Which Features can be done in parallel] 3. **Key dependencies**: [Critical path items] 4. **Risk mitigation**: [High-risk items to address early] @@ -202,7 +202,7 @@ Invoke these agents at the start of the prioritization process. Work collaborati - [ ] Review prioritization with stakeholders - [ ] Confirm roadmap phases - [ ] Begin implementation planning for Phase 1 - - [ ] Create detailed task breakdown for high-priority RFEs + - [ ] Create detailed task breakdown for high-priority Features ``` 5. **Validate Prioritization**: @@ -224,11 +224,11 @@ Invoke these agents at the start of the prioritization process. Work collaborati ─────────────────────────────────────────── Phase 1 MVP Phase 2 Core Phase 3 │ │ │ - ├─ RFE-001 ─────┤ │ - ├─ RFE-002 ──────────────────────┤ - │ RFE-003 ──────┤ │ - │ └─ RFE-004 ──────┤ - │ RFE-005 ──────┤ + ├─ Feature-001 ──┤ │ + ├─ Feature-002 ──────────────────┤ + │ Feature-003 ───┤ │ + │ └─ Feature-004 ──┤ + │ Feature-005 ──┤ ``` ## Cumulative Value Delivery @@ -260,4 +260,4 @@ Invoke these agents at the start of the prioritization process. Work collaborati - Each phase should deliver cohesive value - Document trade-offs and rationale for decisions - Align priorities with PRD goals and success metrics -- Be transparent about what's being deferred and why +- Be transparent about what's being deferred and why \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/.claude/commands/feature.review.md b/workflows/prd-rfe-workflow/.claude/commands/feature.review.md new file mode 100644 index 0000000..7e6d6d1 --- /dev/null +++ b/workflows/prd-rfe-workflow/.claude/commands/feature.review.md @@ -0,0 +1,299 @@ +--- +description: Review Feature artifacts for technical feasibility and implementation readiness. +displayName: feature.review +icon: 🔧 +--- + +## User Input + +```text +$ARGUMENTS +``` + +You **MUST** consider the user input before proceeding (if not empty). + +## Outline + +This command reviews Feature artifacts (Feature master list and individual Feature documents) for technical feasibility, implementation readiness, and quality of technical planning. + +**IMPORTANT: Agent Collaboration** + +You MUST proactively invoke the following collaborating agents to ensure comprehensive Feature review: + +1. **@stella-staff_engineer.md** - For technical feasibility, implementation complexity, and risk assessment +2. **@archie-architect.md** (from bullpen) - For architecture alignment and system-level implications +3. **@neil-test_engineer.md** (from bullpen) - For testing requirements, automation strategy, and cross-team impact analysis +4. **@emma-engineering_manager.md** (from bullpen) - For team capacity planning and delivery coordination +5. **@olivia-product_owner.md** (from bullpen) - For acceptance criteria validation and scope negotiation + +Invoke these agents at the start of the review process. Work collaboratively with them to validate technical approach, assess testability, check capacity, and ensure architecture alignment. + +1. **Load Feature Artifacts**: + - Read `features.md` (required) + - Read individual Feature files from `feature-tasks/*.md` + - Read `prd.md` for context + - Read `prioritization.md` (if exists) + - Consider user input from $ARGUMENTS + +2. **Create Feature Technical Review Report**: Generate `feature-review-report.md`: + + ```markdown + # Feature Technical Feasibility Review Report + + **Date**: [Current Date] + **Reviewer**: Claude Assistant + **Status**: [Ready/Needs Work/Blocked] + + ## Executive Summary + + [Brief overview of Feature technical feasibility and key findings] + + **Total Features Reviewed**: [Count] + **Ready for Implementation**: [Count] + **Need Further Work**: [Count] + **Blocked/High Risk**: [Count] + + **Overall Assessment**: [Ready/Needs Work/Not Ready] + + ## Feature Review Summary + + | Feature ID | Title | Status | Technical Risk | Effort Estimate | Notes | + |------------|-------|--------|----------------|------------------|-------| + | Feature-001 | [Title] | ✅ Ready | Low | 3-5 days | Clear requirements | + | Feature-002 | [Title] | ⚠️ Needs Work | Medium | 5-8 days | Dependency unclear | + | Feature-003 | [Title] | ❌ Blocked | High | Unknown | Missing technical spec | + + ## Detailed Feature Reviews + + ### Feature-001: [Title] - ✅ READY + + **Technical Feasibility**: ✅ Feasible + **Architecture Impact**: ✅ Minimal + **Testing Complexity**: ✅ Straightforward + **Team Capacity**: ✅ Within current skills + **Effort Estimate**: 3-5 days + **Risk Level**: Low + + #### Requirements Quality + - ✅ Clear functional requirements + - ✅ Well-defined acceptance criteria + - ✅ User stories are testable + - ✅ Success metrics defined + + #### Technical Assessment + - ✅ Existing architecture supports this feature + - ✅ No new infrastructure required + - ✅ Standard implementation patterns apply + - ✅ No major integration challenges + + #### Testing Strategy + - ✅ Unit tests: Clear approach identified + - ✅ Integration tests: Standard patterns apply + - ✅ E2E tests: Scenarios well-defined + - ✅ Performance impact: Minimal + + #### Dependencies & Risks + - ✅ No blocking dependencies + - ✅ All required APIs/services available + - ✅ No cross-team coordination required + - ✅ Risk mitigation strategies clear + + #### Recommendations + - **Go/No-Go**: ✅ GO - Ready for implementation + - **Priority**: Can proceed with current priority + - **Team Assignment**: Can be assigned to current team + - **Next Steps**: Begin implementation planning + + --- + + ### Feature-002: [Title] - ⚠️ NEEDS WORK + + **Technical Feasibility**: ⚠️ Feasible with concerns + **Architecture Impact**: ⚠️ Moderate + **Testing Complexity**: ⚠️ Requires additional planning + **Team Capacity**: ⚠️ Requires skill development + **Effort Estimate**: 5-8 days (was 3-5) + **Risk Level**: Medium + + #### Requirements Issues + - ⚠️ Some acceptance criteria need clarification + - ✅ Functional requirements clear + - ⚠️ Edge cases not fully defined + - ✅ Success metrics adequate + + #### Technical Concerns + - ⚠️ Integration complexity higher than estimated + - ⚠️ Performance implications need assessment + - ✅ Architecture pattern is appropriate + - ⚠️ Data migration considerations unclear + + #### Testing Challenges + - ⚠️ Complex integration test scenarios + - ✅ Unit testing approach clear + - ⚠️ E2E testing may require test environment changes + - ⚠️ Performance testing strategy needed + + #### Dependencies & Risks + - ⚠️ Dependency on Feature-001 completion + - ⚠️ External API reliability concerns + - ✅ Team skills adequate with training + - ⚠️ Timeline may slip without risk mitigation + + #### Recommendations + - **Go/No-Go**: ⚠️ CONDITIONAL GO - Address concerns first + - **Required Actions**: + 1. Clarify acceptance criteria with PM + 2. Conduct technical spike for integration approach + 3. Define performance testing strategy + 4. Validate external API reliability + - **Revised Effort**: 5-8 days + - **Next Steps**: Complete required actions, then reassess + + --- + + ### Feature-003: [Title] - ❌ BLOCKED + + **Technical Feasibility**: ❌ Requires significant investigation + **Architecture Impact**: ❌ Major changes required + **Testing Complexity**: ❌ Unclear approach + **Team Capacity**: ❌ Skills gap identified + **Effort Estimate**: Unknown - needs technical design + **Risk Level**: High + + #### Critical Issues + - ❌ Requirements lack technical detail + - ❌ Architecture pattern unclear + - ❌ No clear implementation approach + - ❌ Success criteria not measurable + + #### Technical Blockers + - ❌ Major architectural changes required + - ❌ New technology/framework needed + - ❌ Cross-team dependencies not resolved + - ❌ Performance requirements unclear + + #### Testing Gaps + - ❌ Testing approach undefined + - ❌ Test automation strategy missing + - ❌ Complex integration scenarios + - ❌ Performance testing requirements unclear + + #### Capacity Concerns + - ❌ Team lacks required skills + - ❌ Training/hiring required + - ❌ Timeline unrealistic + - ❌ Resource allocation unclear + + #### Recommendations + - **Go/No-Go**: ❌ NO GO - Major work required before implementation + - **Required Actions**: + 1. Conduct technical design session + 2. Define architecture approach + 3. Assess team skill gaps + 4. Create detailed technical specification + 5. Re-estimate effort after design complete + - **Timeline Impact**: 2-3 weeks for prerequisite work + - **Next Steps**: Schedule technical design workshop + + ## Overall Assessment + + ### Implementation Readiness + - **Ready to Start**: Feature-001 + - **Needs Work**: Feature-002 (1-2 weeks additional planning) + - **Not Ready**: Feature-003 (requires technical design) + + ### Architecture Implications + - **Minimal Impact**: Feature-001 + - **Moderate Impact**: Feature-002 (integration complexity) + - **Major Impact**: Feature-003 (architectural changes required) + + ### Risk Summary + | Risk Category | Low Risk | Medium Risk | High Risk | + |---------------|----------|-------------|-----------| + | Technical Complexity | Feature-001 | Feature-002 | Feature-003 | + | Team Capacity | Feature-001 | Feature-002 | Feature-003 | + | External Dependencies | Feature-001, Feature-002 | | Feature-003 | + | Timeline Risk | Feature-001 | Feature-002 | Feature-003 | + + ### Effort Estimate Adjustments + | Feature ID | Original Estimate | Reviewed Estimate | Confidence | + |------------|-------------------|-------------------|------------| + | Feature-001 | 3-5 days | 3-5 days | High | + | Feature-002 | 3-5 days | 5-8 days | Medium | + | Feature-003 | 5-7 days | Unknown | Low | + + ## Recommendations + + ### Immediate Actions + 1. **Proceed with Feature-001**: Ready for implementation + 2. **Address Feature-002 concerns**: Complete prerequisite work + 3. **Block Feature-003**: Requires technical design before proceeding + + ### Prioritization Adjustments + - **No change needed**: Feature-001 priority remains appropriate + - **Consider deferring**: Feature-002 until concerns addressed + - **Defer to Phase 2**: Feature-003 until technical design complete + + ### Resource Planning + - **Current team capacity**: Sufficient for Feature-001 + - **Additional planning time**: Required for Feature-002 + - **Technical design resources**: Required for Feature-003 + + ### Quality Assurance + - **Testing strategy**: Adequate for ready Features + - **Automation requirements**: Identified for complex Features + - **Performance testing**: Plan for Features with performance impact + + ## Next Steps + + - [ ] Schedule implementation for ready Features + - [ ] Create action plans for Features needing work + - [ ] Schedule technical design sessions for blocked Features + - [ ] Update prioritization based on review findings + - [ ] Communicate findings to product management + ``` + +3. **Generate Individual Feature Review Comments**: + - For each Feature that needs work, add specific technical comments to the individual Feature files + - Update the "Implementation Notes" section with technical concerns + - Add specific action items to the "Open Questions" section + +4. **Review Quality Validation**: + - All high-priority Features have been technically reviewed + - Implementation blockers are identified and documented + - Effort estimates are validated by engineering + - Testing strategies are defined for each Feature + - Architecture implications are understood + +5. **Report Completion**: + - Path to Feature technical review report + - Summary of ready vs. not-ready Features + - Updated effort estimates based on technical review + - Recommended prioritization adjustments + - Next steps for addressing technical concerns + +## Review Criteria + +### Technical Feasibility +- Architecture patterns are appropriate +- Implementation approach is clear +- No major technical unknowns +- Team has required skills + +### Requirements Quality +- Acceptance criteria are testable +- User stories are implementable +- Success metrics are measurable +- Edge cases are considered + +### Testing Strategy +- Unit testing approach is clear +- Integration testing is planned +- E2E scenarios are defined +- Performance testing needs identified + +### Implementation Readiness +- Dependencies are resolved +- API contracts are defined +- Data requirements are clear +- Infrastructure needs understood \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/.claude/commands/feature.speedrun.md b/workflows/prd-rfe-workflow/.claude/commands/feature.speedrun.md new file mode 100644 index 0000000..2e294ca --- /dev/null +++ b/workflows/prd-rfe-workflow/.claude/commands/feature.speedrun.md @@ -0,0 +1,234 @@ +--- +description: Run the complete PRD-Feature workflow automatically from discovery to Jira submission, only pausing for critical questions. +displayName: feature.speedrun +icon: ⚡ +--- + +## User Input + +```text +$ARGUMENTS +``` + +You **MUST** consider the user input before proceeding (if not empty). The user input should contain the initial product idea or problem statement. + +## Outline + +This command automates the entire PRD-Feature workflow from discovery through Jira submission. It runs each phase sequentially, making intelligent decisions and only pausing to ask simplified, critical questions when absolutely necessary. + +**Workflow Phases (in order)**: +1. `/prd.discover` - Product discovery +2. `/prd.rfe` - RFE gathering +3. `/prd.create` - PRD creation +4. `/prd.review` - PRD review +5. `/prd.revise` - PRD revision (if needed, based on review) +6. `/feature.breakdown` - Feature breakdown +7. `/feature.review` - Feature review +8. `/feature.revise` - Feature revision (if needed, based on review) +9. `/feature.prioritize` - Feature prioritization +10. `/feature.submit` - Feature submission to Jira + +## Execution Strategy + +### Phase 1: Discovery (`/prd.discover`) + +1. **Execute Discovery**: + - Run the discovery phase using the user's initial input + - Invoke collaborating agents: @parker-product_manager.md, @ryan-ux_researcher.md, @aria-ux_architect.md + - Generate `discovery.md` + - Make reasonable assumptions when information is missing + - Only ask questions if critical information is completely absent + +2. **Critical Questions (only if needed)**: + - "Who are the primary users?" (if not inferable from context) + - "What is the main problem being solved?" (if not clear from input) + - Maximum 2-3 questions total + +3. **Proceed automatically** to RFE phase + +### Phase 2: RFE (`/prd.rfe`) + +1. **Execute Requirements Gathering**: + - Transform discovery insights into specific requirements + - Invoke collaborating agents: @parker-product_manager.md, @ryan-ux_researcher.md, @olivia-product_owner.md, @aria-ux_architect.md + - Generate `rfe.md` + - Use MoSCoW prioritization by default + - Make intelligent assumptions about requirement priorities + +2. **No questions** - proceed automatically to PRD creation + +### Phase 3: PRD Creation (`/prd.create`) + +1. **Execute PRD Creation**: + - Create comprehensive PRD from requirements + - Invoke collaborating agents: @parker-product_manager.md, @ryan-ux_researcher.md, @terry-technical_writer.md, @casey-content_strategist.md + - Generate `prd.md` and `prd-checklist.md` + - Include all standard sections: Executive Summary, Goals, User Stories, Requirements, Success Metrics + +2. **No questions** - proceed automatically to PRD review + +### Phase 4: PRD Review (`/prd.review`) + +1. **Execute PRD Review**: + - Review PRD for completeness and quality + - Invoke collaborating agents: @steve-ux_designer.md, @aria-ux_architect.md, @olivia-product_owner.md, @archie-architect.md + - Generate `prd-review-report.md` + - Identify areas needing improvement + +2. **Automatic Decision Making**: + - If review score > 80%: proceed to Feature breakdown + - If review score 60-80%: run `/prd.revise` once, then proceed + - If review score < 60%: ask user if they want to continue or stop for manual revision + +### Phase 5: PRD Revision (`/prd.revise`) - Conditional + +1. **Execute if Needed**: + - Only run if review score was 60-80% + - Address major gaps identified in review + - Invoke collaborating agents: @parker-product_manager.md, @terry-technical_writer.md + - Update `prd.md` + +2. **No questions** - proceed automatically to Feature breakdown + +### Phase 6: Feature Breakdown (`/feature.breakdown`) + +1. **Execute Feature Breakdown**: + - Break PRD into discrete Feature items + - Invoke collaborating agents: @olivia-product_owner.md, @stella-staff_engineer.md, @archie-architect.md, @neil-test_engineer.md + - Generate `features.md` and individual Feature files in `feature-tasks/` + - Apply intelligent sizing (S/M/L/XL) based on complexity + +2. **Automatic Decision Making**: + - Target 5-12 Features total (break down further if > 12, combine if < 5) + - Ensure each Feature is independently deliverable + - Automatically identify dependencies + +3. **No questions** - proceed automatically to Feature review + +### Phase 7: Feature Review (`/feature.review`) + +1. **Execute Feature Review**: + - Review Features for technical feasibility + - Invoke collaborating agents: @stella-staff_engineer.md, @archie-architect.md, @neil-test_engineer.md, @emma-engineering_manager.md, @olivia-product_owner.md + - Generate `feature-review-report.md` + - Assess technical risks and implementation readiness + +2. **Automatic Decision Making**: + - If > 80% of Features are "Ready": proceed to prioritization + - If 60-80% of Features are "Ready": run `/feature.revise` on problematic Features, then proceed + - If < 60% of Features are "Ready": ask user if they want to continue or stop for manual review + +### Phase 8: Feature Revision (`/feature.revise`) - Conditional + +1. **Execute if Needed**: + - Only run if 60-80% of Features were "Ready" in review + - Focus on Features marked as "Needs Work" + - Invoke collaborating agents: @olivia-product_owner.md, @stella-staff_engineer.md, @neil-test_engineer.md + - Update individual Feature files in `feature-tasks/` + +2. **No questions** - proceed automatically to Feature prioritization + +### Phase 9: Feature Prioritization (`/feature.prioritize`) + +1. **Execute Feature Prioritization**: + - Apply RICE scoring by default (use reasonable assumptions for missing data) + - Invoke collaborating agents: @parker-product_manager.md, @olivia-product_owner.md, @emma-engineering_manager.md + - Generate `prioritization.md` and optional `roadmap-visual.md` + - Create 3-phase roadmap by default + +2. **Intelligent Assumptions**: + - **Reach**: Estimate based on user base described in PRD + - **Impact**: High=3, Medium=2, Low=1 based on business goals + - **Confidence**: 80% default for well-defined Features, 50% for uncertain ones + - **Effort**: Use size estimates from Feature breakdown + +3. **No questions** - proceed automatically to Feature submission + +### Phase 10: Feature Submission (`/feature.submit`) + +1. **Execute Feature Submission**: + - Format Features for Jira submission + - Invoke collaborating agents: @olivia-product_owner.md, @emma-engineering_manager.md, @parker-product_manager.md + - Generate `jira-tickets.md` (or submission instructions if no Jira MCP) + - If Jira MCP available: automatically create tickets + - If no Jira MCP: provide detailed manual instructions + +2. **Final Report**: + - Summarize entire workflow results + - Provide links to all generated artifacts + - Include next steps for implementation + +## Speedrun Guidelines + +### Minimize Questions +- **Maximum 5 questions total** across the entire workflow +- Only ask when critical information is completely missing +- Prefer making intelligent assumptions over asking questions +- Group related questions together when possible + +### Make Intelligent Assumptions +- **User personas**: Infer from problem description +- **Market size**: Use industry standards or reasonable estimates +- **Technical approach**: Choose standard/proven patterns +- **Priorities**: Align with common business goals (revenue, user satisfaction, efficiency) +- **Effort estimates**: Use pattern recognition from similar features + +### Error Recovery +- If a phase fails, try once more with adjusted parameters +- If still failing, ask user whether to continue or stop +- Always prefer partial completion over total failure + +### Quality vs. Speed Balance +- Aim for 80% quality - good enough for most use cases +- Focus on completeness over perfection +- Ensure all required artifacts are generated +- Identify major gaps that need human review + +## Execution Flow + +```mermaid +flowchart TD + A[User Input] --> B[prd.discover] + B --> C[prd.rfe] + C --> D[prd.create] + D --> E[prd.review] + E --> F{Review Score} + F -->|>80%| H[feature.breakdown] + F -->|60-80%| G[prd.revise] + F -->|<60%| Q1[Ask: Continue?] + G --> H + Q1 -->|Yes| H + Q1 -->|No| END[Stop for Manual Review] + + H --> I[feature.review] + I --> J{Features Ready} + J -->|>80%| L[feature.prioritize] + J -->|60-80%| K[feature.revise] + J -->|<60%| Q2[Ask: Continue?] + K --> L + Q2 -->|Yes| L + Q2 -->|No| END + + L --> M[feature.submit] + M --> N[Final Report] +``` + +## Success Criteria + +- All 10 workflow phases complete successfully +- All required artifacts generated (discovery.md, rfe.md, prd.md, features.md, feature-tasks/, prioritization.md) +- Features are ready for implementation or have clear next steps +- User has actionable roadmap for proceeding +- Total execution takes 30-60 minutes for most projects + +## Final Deliverables + +Upon completion, the user receives: +- **Complete PRD** (`prd.md`) with business case and requirements +- **Feature Master List** (`features.md`) with breakdown and effort estimates +- **Individual Feature Documents** (`feature-tasks/*.md`) ready for development +- **Prioritized Roadmap** (`prioritization.md`) with implementation phases +- **Jira Integration** (`jira-tickets.md`) for ticket creation or manual instructions +- **Summary Report** with next steps and recommendations + +This enables immediate transition from idea to implementation planning without manual workflow orchestration. \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/.claude/commands/feature.submit.md b/workflows/prd-rfe-workflow/.claude/commands/feature.submit.md new file mode 100644 index 0000000..3a99ab1 --- /dev/null +++ b/workflows/prd-rfe-workflow/.claude/commands/feature.submit.md @@ -0,0 +1,323 @@ +--- +description: Submit Features to Jira for implementation planning and team assignment. +displayName: feature.submit +icon: 🎫 +--- + +## User Input + +```text +$ARGUMENTS +``` + +You **MUST** consider the user input before proceeding (if not empty). + +## Outline + +This command submits Features to Jira for implementation planning. It should be run after `/feature.breakdown` and optionally after `/feature.prioritize`. + +**IMPORTANT: Agent Collaboration** + +You MUST proactively invoke the following collaborating agents to ensure proper Feature submission: + +1. **@olivia-product_owner.md** (from bullpen) - For backlog prioritization, sprint planning, and ticket structure +2. **@emma-engineering_manager.md** (from bullpen) - For team assignment, capacity allocation, and delivery coordination +3. **@parker-product_manager.md** - For roadmap alignment and stakeholder communication + +Invoke these agents at the start of the submission process. Work collaboratively with them to ensure tickets are properly structured, prioritized, and assigned. + +1. **Load Context**: + - Read `features.md` (Feature master list) + - Read all individual Feature files from `feature-tasks/` directory + - Check if prioritization document exists (`prioritization.md`) + - Consider user input from $ARGUMENTS + +2. **Check Jira MCP Server Availability**: + - Attempt to detect if Jira MCP server is available + - If available, proceed with automated ticket creation (Step 3) + - If not available, provide manual submission instructions (Step 4) + +3. **Automated Jira Ticket Creation** (if Jira MCP available): + + For each Feature in the master list: + + a. **Read Feature File**: + - Load `feature-tasks/Feature-XXX-[slug].md` + - Extract key information: + - Feature ID and title + - Summary + - Priority and size + - Acceptance criteria + - Dependencies + - Technical notes + + b. **Create Jira Ticket**: + ```json + { + "summary": "Feature-XXX: [Title from Feature]", + "description": { + "type": "doc", + "content": [ + { + "type": "paragraph", + "content": [ + {"type": "text", "text": "[Feature Summary]"} + ] + }, + { + "type": "heading", + "attrs": {"level": 2}, + "content": [{"type": "text", "text": "Problem Statement"}] + }, + { + "type": "paragraph", + "content": [ + {"type": "text", "text": "[Problem statement from Feature]"} + ] + }, + { + "type": "heading", + "attrs": {"level": 2}, + "content": [{"type": "text", "text": "Acceptance Criteria"}] + }, + { + "type": "bulletList", + "content": [ + { + "type": "listItem", + "content": [ + { + "type": "paragraph", + "content": [{"type": "text", "text": "[Criterion 1]"}] + } + ] + } + ] + }, + { + "type": "heading", + "attrs": {"level": 2}, + "content": [{"type": "text", "text": "Technical Notes"}] + }, + { + "type": "paragraph", + "content": [ + {"type": "text", "text": "[Technical approach and considerations]"} + ] + } + ] + }, + "priority": "[High/Medium/Low based on Feature priority]", + "labels": ["feature", "prd-derived", "[size]", "[epic-name]"], + "customFields": { + "Story Points": "[Convert S=1, M=3, L=5, XL=8]", + "Epic Link": "[Epic from PRD if available]", + "Team": "[Team assignment if specified]" + } + } + ``` + + c. **Link Dependencies**: + - For each dependency listed in Feature file + - Find corresponding Jira ticket + - Create "blocks"/"blocked by" link + + d. **Attach Feature File**: + - Attach the complete Feature markdown file to ticket + - This provides full technical specification for implementation + +4. **Manual Submission Instructions** (if no Jira MCP): + + Generate `jira-submission-guide.md`: + + ```markdown + # Jira Ticket Creation Guide + + **Features Ready for Submission**: [Count] + **Source Documents**: features.md, feature-tasks/*.md + + ## Quick Setup + + 1. **Create Epic** (if not exists): + - **Summary**: [PRD Title] + - **Description**: Link to PRD and overview + - **Labels**: epic, prd + + 2. **Set up Components/Labels**: + - Labels: feature, prd-derived, [team-name] + - Components: [relevant product areas] + + ## Individual Ticket Creation + + ### Feature-001: [Title] + + **Create New Story/Task in Jira**: + + **Summary**: Feature-001: [Feature Title] + + **Description**: + ``` + ## Summary + [Feature summary from Feature file] + + ## Problem Statement + [Problem statement from Feature file] + + ## Acceptance Criteria + - [ ] [Criterion 1] + - [ ] [Criterion 2] + - [ ] [Criterion 3] + + ## Technical Notes + [Technical approach and considerations] + + ## Dependencies + - Blocks: [List of dependent Feature IDs] + - Depends on: [List of prerequisite Feature IDs] + + ## Reference + Feature File: feature-tasks/Feature-001-[slug].md + PRD: prd.md + ``` + + **Fields to Set**: + - **Priority**: [High/Medium/Low] + - **Story Points**: [S=1, M=3, L=5, XL=8] + - **Epic Link**: [Epic key] + - **Labels**: feature, prd-derived, [size], [team] + - **Assignee**: [Team/Individual if known] + - **Sprint**: [Current/Future sprint if planned] + + **Attachments**: + - Upload: feature-tasks/Feature-001-[slug].md + + --- + + [Repeat for each Feature] + + ## Dependency Linking + + After all tickets are created: + + 1. **Feature-001** (Foundation): + - Link as "blocks" → Feature-003, Feature-004 + + 2. **Feature-003** (Depends on 001): + - Link as "is blocked by" → Feature-001 + + 3. **Feature-005** (Depends on 003): + - Link as "is blocked by" → Feature-003 + + ## Backlog Organization + + ### Sprint Planning Order + + **Sprint 1**: Foundation Features + - Feature-001 (High priority, no dependencies) + - Feature-002 (Medium priority, independent) + + **Sprint 2**: Core Features + - Feature-003 (Depends on Feature-001) + - Feature-004 (Independent, medium priority) + + **Sprint 3**: Enhancement Features + - Feature-005 (Depends on Feature-003) + - Feature-006 (Low priority) + + ## Team Assignment + + Based on feature complexity and team skills: + + - **Frontend Team**: Feature-001, Feature-004 (UI-heavy) + - **Backend Team**: Feature-002, Feature-003 (API/service work) + - **Full-Stack Team**: Feature-005 (mixed requirements) + + ## Estimation Validation + + Review and adjust story points during planning poker: + + | Feature | Initial Estimate | Team Estimate | Notes | + |---------|------------------|---------------|-------| + | Feature-001 | 3 | [TBD] | [Team feedback] | + | Feature-002 | 5 | [TBD] | [Team feedback] | + ``` + +5. **Create Feature-to-Jira Mapping Document**: Generate `jira-tickets.md`: + + ```markdown + # Feature to Jira Ticket Mapping + + **Created**: [Date] + **Method**: [Automated/Manual] + **Total Features**: [Count] + + ## Ticket Mapping + + | Feature ID | Jira Ticket | Title | Priority | Status | + |------------|-------------|-------|----------|--------| + | Feature-001 | [PROJ-123] | [Feature Title] | High | Created | + | Feature-002 | [PROJ-124] | [Feature Title] | Medium | Created | + | Feature-003 | [PROJ-125] | [Feature Title] | High | Created | + + ## Epic Mapping + + | Epic Name | Jira Epic | Features Included | + |-----------|-----------|-------------------| + | [Epic 1] | [PROJ-100] | Feature-001, Feature-002 | + | [Epic 2] | [PROJ-101] | Feature-003, Feature-004 | + + ## Dependency Links + + | Feature | Blocks | Blocked By | + |---------|--------|------------| + | Feature-001 | Feature-003, Feature-004 | None | + | Feature-003 | Feature-005 | Feature-001 | + + ## Next Steps + + - [ ] Review tickets with development team + - [ ] Validate story point estimates + - [ ] Assign to appropriate team members + - [ ] Schedule for upcoming sprints + - [ ] Set up automated notifications + - [ ] Create sprint goals aligned with Feature priorities + ``` + +6. **Validation and Quality Check**: + - Verify all Features from master list have corresponding tickets/instructions + - Check that dependencies are properly linked + - Ensure ticket descriptions contain all necessary information + - Validate priority alignment with prioritization document + +7. **Report Completion**: + - Summary of tickets created/instructions provided + - Path to Jira mapping document + - Next steps for development team + - Recommended sprint planning approach + +## Submission Guidelines + +### Ticket Quality Standards +- **Summary**: Clear, action-oriented feature description +- **Description**: Includes problem statement, acceptance criteria, and technical notes +- **Acceptance Criteria**: Testable, specific, measurable +- **Dependencies**: All blocking/blocked relationships mapped +- **Attachments**: Complete Feature specification file attached + +### Priority Mapping +- **High Priority**: Critical path features, MVP requirements +- **Medium Priority**: Important but not blocking features +- **Low Priority**: Nice-to-have features for later phases + +### Story Point Guidelines +- **1 Point (S)**: Simple feature, 1-3 days, minimal integration +- **3 Points (M)**: Moderate feature, 3-5 days, some complexity +- **5 Points (L)**: Complex feature, 5-8 days, significant integration +- **8 Points (XL)**: Very complex, 8+ days, consider breaking down + +### Label Standards +- **feature**: Identifies ticket as feature (vs. bug/task) +- **prd-derived**: Indicates ticket originated from PRD process +- **[size]**: s, m, l, xl for quick size identification +- **[team]**: frontend, backend, fullstack, etc. +- **[epic-name]**: Short epic identifier for grouping \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/.claude/commands/prd.create.md b/workflows/prd-rfe-workflow/.claude/commands/prd.create.md index 344bfd3..ab45cb8 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/prd.create.md +++ b/workflows/prd-rfe-workflow/.claude/commands/prd.create.md @@ -14,7 +14,7 @@ You **MUST** consider the user input before proceeding (if not empty). ## Outline -This command creates the final PRD document. It should be run after `/prd.requirements`. +This command creates the final PRD document. It should be run after `/prd.rfe`. **IMPORTANT: Agent Collaboration** @@ -29,7 +29,7 @@ Invoke these agents throughout the PRD creation process. Work collaboratively wi 1. **Load Context**: - Read `discovery.md` if it exists - - Read `requirements.md` if it exists + - Read `rfe.md` if it exists - Consider user input from $ARGUMENTS 2. **Create PRD**: Generate `prd.md` with comprehensive structure: @@ -278,12 +278,12 @@ Invoke these agents throughout the PRD creation process. Work collaboratively wi ## Stakeholder Readiness - [ ] PRD is ready for review - [ ] All open questions are resolved - - [ ] Document is comprehensive enough for RFE breakdown + - [ ] Document is comprehensive enough for Feature breakdown ## Next Steps - [ ] Review PRD with stakeholders - [ ] Get PRD approval - - [ ] Proceed to RFE breakdown (/rfe.breakdown) + - [ ] Proceed to Feature breakdown (/feature.breakdown) ``` 6. **Report Completion**: diff --git a/workflows/prd-rfe-workflow/.claude/commands/prd.discover.md b/workflows/prd-rfe-workflow/.claude/commands/prd.discover.md index 107000d..69aa253 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/prd.discover.md +++ b/workflows/prd-rfe-workflow/.claude/commands/prd.discover.md @@ -107,7 +107,7 @@ Given that initial input, do this: 5. **Report Completion**: - Path to discovery document - Key insights summary - - Recommendation on next steps (run `/prd.requirements` if ready) + - Recommendation on next steps (run `/prd.rfe` if ready) ## Guidelines diff --git a/workflows/prd-rfe-workflow/.claude/commands/prd.review.md b/workflows/prd-rfe-workflow/.claude/commands/prd.review.md index 41cc281..564c987 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/prd.review.md +++ b/workflows/prd-rfe-workflow/.claude/commands/prd.review.md @@ -29,7 +29,7 @@ Invoke these agents at the start of the review process. Work collaboratively wit 1. **Load PRD Artifacts**: - Read `discovery.md` (if exists) - - Read `requirements.md` (if exists) + - Read `rfe.md` (if exists) - Read `prd.md` (required) - Consider user input from $ARGUMENTS @@ -241,7 +241,7 @@ Invoke these agents at the start of the review process. Work collaboratively wit ## Overall Assessment - **Readiness Status**: [Ready for RFE Breakdown / Needs Minor Revisions / Needs Major Revisions] + **Readiness Status**: [Ready for Feature Breakdown / Needs Minor Revisions / Needs Major Revisions] **Summary**: [Overall assessment of PRD completeness and readiness] @@ -281,7 +281,7 @@ Invoke these agents at the start of the review process. Work collaboratively wit - Provide specific recommendations for addressing each gap 6. **Assess Readiness**: - - Determine if PRD is ready for RFE breakdown + - Determine if PRD is ready for Feature breakdown - Score threshold: >80% = Ready, 60-80% = Needs Minor Revisions, <60% = Needs Major Revisions - Provide clear next steps @@ -294,7 +294,7 @@ Invoke these agents at the start of the review process. Work collaboratively wit 8. **Interactive Follow-up**: - If gaps found, ask if user wants to address them now - - Suggest which commands to re-run (e.g., `/prd.discover`, `/prd.requirements`, `/prd.create`) + - Suggest which commands to re-run (e.g., `/prd.discover`, `/prd.rfe`, `/prd.create`) - Offer to help fill specific gaps ## Guidelines diff --git a/workflows/prd-rfe-workflow/.claude/commands/prd.requirements.md b/workflows/prd-rfe-workflow/.claude/commands/prd.rfe.md similarity index 95% rename from workflows/prd-rfe-workflow/.claude/commands/prd.requirements.md rename to workflows/prd-rfe-workflow/.claude/commands/prd.rfe.md index 11cc754..1108708 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/prd.requirements.md +++ b/workflows/prd-rfe-workflow/.claude/commands/prd.rfe.md @@ -1,6 +1,6 @@ --- -description: Gather and document detailed product requirements. -displayName: prd.requirements +description: Gather and document detailed product requirements in an RFE. +displayName: prd.rfe icon: 📋 --- @@ -31,7 +31,7 @@ Invoke these agents at the start of the requirements gathering process. Work col - Read `discovery.md` if it exists - Consider user input from $ARGUMENTS -2. **Create Requirements Document**: Generate `requirements.md`: +2. **Create RFE Document**: Generate `rfe.md`: ```markdown # Product Requirements: [Product/Feature Name] @@ -139,7 +139,7 @@ Invoke these agents at the start of the requirements gathering process. Work col - Present options when multiple approaches are valid 6. **Report Completion**: - - Path to requirements document + - Path to RFE document - Summary of key requirements - Readiness assessment for PRD creation - Next step: run `/prd.create` diff --git a/workflows/prd-rfe-workflow/.claude/commands/prd.sources.md b/workflows/prd-rfe-workflow/.claude/commands/prd.sources.md index c472d1d..bbd2024 100644 --- a/workflows/prd-rfe-workflow/.claude/commands/prd.sources.md +++ b/workflows/prd-rfe-workflow/.claude/commands/prd.sources.md @@ -19,7 +19,7 @@ This command generates a comprehensive list of all data sources that informed th 1. **Load Context**: - Read `prd.md` (required) - Read `discovery.md` (if exists) - - Read `requirements.md` (if exists) + - Read `rfe.md` (if exists) - Read `prd-review-report.md` (if exists) - Scan for any references, citations, or links in these documents @@ -61,7 +61,7 @@ This command generates a comprehensive list of all data sources that informed th ### Internal Documentation - Internal wiki pages - - Previous PRDs or RFEs referenced + - Previous PRDs or Features referenced - Design documents or specifications - Architecture documents - Process documentation diff --git a/workflows/prd-rfe-workflow/.claude/commands/rfe.review.md b/workflows/prd-rfe-workflow/.claude/commands/rfe.review.md deleted file mode 100644 index 9608db4..0000000 --- a/workflows/prd-rfe-workflow/.claude/commands/rfe.review.md +++ /dev/null @@ -1,421 +0,0 @@ ---- -description: Review RFE artifacts for technical feasibility and implementation readiness. -displayName: rfe.review -icon: 🔧 ---- - -## User Input - -```text -$ARGUMENTS -``` - -You **MUST** consider the user input before proceeding (if not empty). - -## Outline - -This command reviews RFE artifacts (RFE master list and individual RFE documents) for technical feasibility, implementation readiness, and quality of technical planning. - -**IMPORTANT: Agent Collaboration** - -You MUST proactively invoke the following collaborating agents to ensure comprehensive RFE review: - -1. **@stella-staff_engineer.md** - For technical feasibility, implementation complexity, and risk assessment -2. **@archie-architect.md** (from bullpen) - For architecture alignment and system-level implications -3. **@neil-test_engineer.md** (from bullpen) - For testing requirements, automation strategy, and cross-team impact analysis -4. **@emma-engineering_manager.md** (from bullpen) - For team capacity planning and delivery coordination -5. **@olivia-product_owner.md** (from bullpen) - For acceptance criteria validation and scope negotiation - -Invoke these agents at the start of the review process. Work collaboratively with them to validate technical approach, assess testability, check capacity, and ensure architecture alignment. - -1. **Load RFE Artifacts**: - - Read `rfes.md` (required) - - Read individual RFE files from `rfe-tasks/*.md` - - Read `prd.md` for context - - Read `prioritization.md` (if exists) - - Consider user input from $ARGUMENTS - -2. **Create RFE Technical Review Report**: Generate `rfe-review-report.md`: - - ```markdown - # RFE Technical Feasibility Review Report - - **Date**: [Current Date] - **Reviewer**: Claude Assistant - **Status**: [Ready/Needs Work/Blocked] - - ## Executive Summary - - [Brief overview of RFE technical feasibility and key findings] - - **Total RFEs Reviewed**: [Count] - **Technically Feasible**: [Count] - **Needs Clarification**: [Count] - **High Risk**: [Count] - **Blocked**: [Count] - - --- - - ## Technical Feasibility Assessment - - ### Overall Technical Readiness - - | Category | Score | Status | - |----------|-------|--------| - | Technical Clarity | X/10 | ✅/⚠️/❌ | - | Implementation Scope | X/10 | ✅/⚠️/❌ | - | Dependency Management | X/10 | ✅/⚠️/❌ | - | Risk Assessment | X/10 | ✅/⚠️/❌ | - | Resource Requirements | X/10 | ✅/⚠️/❌ | - | Testing Strategy | X/10 | ✅/⚠️/❌ | - - **Overall Technical Feasibility Score**: X/60 ([Percentage]%) - - ### Scoring Legend - - ✅ Strong (8-10): Ready for implementation - - ⚠️ Moderate (5-7): Needs clarification or planning - - ❌ Weak (0-4): Significant concerns or blockers - - --- - - ## Per-RFE Technical Analysis - - ### RFE-001: [Title] - - **Technical Feasibility**: ✅ Feasible / ⚠️ Needs Work / ❌ High Risk / 🚫 Blocked - - #### Technical Clarity - - **Score**: X/10 - - **Assessment**: [Is the technical approach clear? Are integration points identified?] - - **Gaps**: [What technical details are missing?] - - **Recommendations**: [What needs to be clarified?] - - #### Scope & Complexity - - **Score**: X/10 - - **Estimated Complexity**: Low / Medium / High / Very High - - **Assessment**: [Is the scope well-defined? Is sizing appropriate?] - - **Concerns**: [Scope creep risks, underestimation issues] - - **Recommendations**: [Should it be split? Combined? Rescoped?] - - #### Dependencies & Integration - - **Score**: X/10 - - **Internal Dependencies**: [List RFE dependencies and their status] - - **External Dependencies**: [APIs, services, libraries, teams] - - **Assessment**: [Are all dependencies identified and available?] - - **Risks**: [Dependency-related risks] - - **Recommendations**: [How to handle dependencies] - - #### Technical Risks - - **Score**: X/10 - - **Identified Risks**: - 1. [Risk 1]: [Description, likelihood, impact] - 2. [Risk 2]: [Description, likelihood, impact] - - **Mitigation Strategies**: [How to address each risk] - - **Showstoppers**: [Any blocking technical issues] - - **Recommendations**: [Risk mitigation steps] - - #### Resource Requirements - - **Score**: X/10 - - **Skills Needed**: [Technical skills/expertise required] - - **Infrastructure**: [Servers, databases, services needed] - - **Third-party Services**: [External services/APIs required] - - **Assessment**: [Are resources available and accessible?] - - **Gaps**: [Missing resources or capabilities] - - **Recommendations**: [Resource acquisition/allocation needs] - - #### Testing Strategy - - **Score**: X/10 - - **Test Coverage**: [Unit, integration, E2E plans documented?] - - **Test Complexity**: [How difficult to test? Special environments needed?] - - **Assessment**: [Is testing approach comprehensive and realistic?] - - **Gaps**: [Missing test scenarios or strategies] - - **Recommendations**: [Testing improvements needed] - - #### Implementation Approach - - **Suggested Architecture**: [High-level technical architecture] - - **Key Components**: [Main technical components to build] - - **Integration Points**: [Where this connects to existing systems] - - **Data Flow**: [How data moves through the system] - - **Technical Considerations**: [Performance, security, scalability notes] - - #### Effort Estimate Validation - - **Current Estimate**: [S/M/L/XL from RFE] - - **Validated Estimate**: [Revised estimate based on technical review] - - **Confidence Level**: High / Medium / Low - - **Justification**: [Why this estimate is appropriate] - - **Recommendation**: [Keep estimate / Revise to X / Split into multiple RFEs] - - #### Readiness Assessment - - **Ready for Implementation**: Yes / No / With Conditions - - **Blocking Issues**: [List any blockers] - - **Prerequisites**: [What must be done first] - - **Next Steps**: [Actions needed before starting implementation] - - --- - - [Repeat for each RFE] - - --- - - ## Cross-RFE Technical Analysis - - ### Architecture Coherence - - **Assessment**: [Do RFEs work together cohesively? Any architectural conflicts?] - - **Concerns**: [Inconsistencies, overlaps, gaps in overall architecture] - - **Recommendations**: [Architectural improvements needed] - - ### Dependency Graph Validation - - **Circular Dependencies**: [Any found? How to resolve?] - - **Critical Path**: [What's the longest dependency chain?] - - **Parallel Work Opportunities**: [Which RFEs can be done concurrently?] - - **Bottlenecks**: [RFEs that block many others] - - **Recommendations**: [Resequencing or restructuring suggestions] - - ### Technology Stack Alignment - - **Technologies Used**: [List all technologies across RFEs] - - **Consistency**: [Are tech choices aligned? Any conflicts?] - - **New Technologies**: [Any new tech being introduced? Training needed?] - - **Concerns**: [Tech stack fragmentation, version conflicts, etc.] - - **Recommendations**: [Standardization or consolidation needed] - - ### Resource Capacity Analysis - - **Skill Gaps**: [Technical skills needed but not available] - - **Infrastructure Needs**: [New infrastructure requirements] - - **Third-party Dependencies**: [External services/APIs needed] - - **Bottleneck Resources**: [Scarce resources needed by multiple RFEs] - - **Recommendations**: [Resource acquisition or allocation strategy] - - ### Risk Aggregation - - **High-Risk RFEs**: [Count and list] - - **Common Risk Patterns**: [Risks appearing across multiple RFEs] - - **Systemic Risks**: [Risks to overall project success] - - **Cumulative Risk**: [Overall project risk level: Low/Medium/High/Very High] - - **Recommendations**: [Risk mitigation priorities] - - --- - - ## Critical Issues & Blockers - - ### Blocking Issues (Must Resolve Before Starting) - 1. **[Issue 1]** - - **Affected RFEs**: [List] - - **Description**: [What's blocking] - - **Impact**: [High/Medium/Low] - - **Resolution**: [How to resolve] - - **Owner**: [Who needs to resolve] - - 2. **[Issue 2]** - - **Affected RFEs**: [List] - - **Description**: [What's blocking] - - **Impact**: [High/Medium/Low] - - **Resolution**: [How to resolve] - - **Owner**: [Who needs to resolve] - - ### High-Priority Issues (Address Soon) - 1. **[Issue 1]**: [Description and recommended action] - 2. **[Issue 2]**: [Description and recommended action] - - ### Medium-Priority Issues (Address Eventually) - 1. **[Issue 1]**: [Description and recommended action] - 2. **[Issue 2]**: [Description and recommended action] - - --- - - ## Feasibility by Priority Tier - - ### High-Priority RFEs - - **Total**: [Count] - - **Technically Ready**: [Count] - - **Needs Work**: [Count] - - **Blocked**: [Count] - - **Assessment**: [Can high-priority work begin?] - - ### Medium-Priority RFEs - - **Total**: [Count] - - **Technically Ready**: [Count] - - **Needs Work**: [Count] - - **Blocked**: [Count] - - **Assessment**: [Technical state of medium-priority work] - - ### Low-Priority RFEs - - **Total**: [Count] - - **Technically Ready**: [Count] - - **Needs Work**: [Count] - - **Blocked**: [Count] - - **Assessment**: [Technical state of low-priority work] - - --- - - ## Implementation Roadmap Validation - - ### Phase 1 Feasibility - - **RFEs in Phase**: [List] - - **Technical Readiness**: [Assessment] - - **Blocking Issues**: [Any blockers?] - - **Parallel Work**: [Which can run concurrently?] - - **Recommendation**: [Ready to start / Needs preparation] - - ### Phase 2 Feasibility - - **RFEs in Phase**: [List] - - **Technical Readiness**: [Assessment] - - **Dependencies from Phase 1**: [Properly sequenced?] - - **Recommendation**: [Assessment] - - ### Phase 3+ Feasibility - - **RFEs in Phase**: [List] - - **Technical Readiness**: [Assessment] - - **Long-term Risks**: [Any concerns?] - - **Recommendation**: [Assessment] - - --- - - ## Recommendations - - ### Immediate Actions (Before Implementation Starts) - 1. **[Action 1]**: [Specific technical task] - - **Priority**: High/Medium/Low - - **Effort**: [Estimate] - - **Owner**: [Who should do this] - - 2. **[Action 2]**: [Specific technical task] - - **Priority**: High/Medium/Low - - **Effort**: [Estimate] - - **Owner**: [Who should do this] - - ### RFE Modifications Recommended - 1. **RFE-XXX**: [Split into smaller RFEs / Merge with RFE-YYY / Rescope / Reprioritize] - - **Reason**: [Why this change is needed] - - **Impact**: [Effect on timeline/scope] - - 2. **RFE-YYY**: [Modification recommended] - - **Reason**: [Why this change is needed] - - **Impact**: [Effect on timeline/scope] - - ### Technical Debt Considerations - - **Shortcuts Identified**: [Quick wins that may create tech debt] - - **Debt Acceptance**: [Which shortcuts are acceptable given constraints?] - - **Mitigation Plan**: [How to address tech debt later] - - ### Prototype/Spike Recommendations - - **[Technology/Approach 1]**: [Why a spike is needed before committing] - - **[Technology/Approach 2]**: [Why a prototype would reduce risk] - - --- - - ## Overall Assessment - - **Technical Feasibility Rating**: [Strong/Moderate/Weak/Blocked] - - **Summary**: [Overall technical assessment - can this project be implemented successfully?] - - **Confidence Level**: [High/Medium/Low confidence in technical success] - - **Key Strengths**: - - [Technical strength 1] - - [Technical strength 2] - - **Key Concerns**: - - [Technical concern 1] - - [Technical concern 2] - - **Go/No-Go Recommendation**: [Proceed / Proceed with Conditions / Major Rework Needed / Do Not Proceed] - - **Conditions for Proceeding** (if applicable): - 1. [Condition 1 that must be met] - 2. [Condition 2 that must be met] - - --- - - ## Next Steps - - ### If Ready to Proceed - 1. [Action 1] - 2. [Action 2] - 3. [Action 3] - - ### If Rework Needed - 1. [What needs to be reworked] - 2. [Which commands to re-run] - 3. [Additional planning required] - - ### If Blocked - 1. [What needs to be unblocked] - 2. [Who needs to be involved] - 3. [Timeline for resolution] - - --- - - ## Sign-off - - **Reviewed by**: Claude Assistant - **Date**: [Current Date] - **Technical Recommendation**: [Proceed / Conditional Proceed / Rework / Block] - ``` - -3. **Perform Technical Feasibility Analysis**: - - For each RFE, systematically evaluate: - - - **Technical Clarity**: How well-defined is the technical approach? - - **Scope Assessment**: Is the scope realistic and well-bounded? - - **Dependencies**: Are all technical dependencies identified and manageable? - - **Risks**: What could go wrong technically? How severe? - - **Resources**: Are the necessary skills, infrastructure, and services available? - - **Testing**: Can this be tested effectively? Is the test strategy sound? - -4. **Score Each RFE**: - - Evaluate each category on a 0-10 scale - - Aggregate scores for overall technical feasibility - - Identify RFEs that are ready vs. need work vs. blocked - -5. **Validate Dependencies**: - - Check for circular dependencies - - Identify critical path - - Find opportunities for parallel work - - Flag dependency risks - -6. **Assess Technical Risks**: - - Identify technical risks in each RFE - - Look for common risk patterns - - Evaluate cumulative/systemic risks - - Propose mitigation strategies - -7. **Validate Effort Estimates**: - - Review sizing estimates against technical complexity - - Flag underestimated or overestimated RFEs - - Recommend estimate adjustments - - Suggest splitting overly large RFEs - -8. **Evaluate Implementation Readiness**: - - Determine which RFEs are ready to start - - Identify blocking issues - - List prerequisites for each RFE - - Provide go/no-go recommendation - -9. **Report Findings**: - - Display technical feasibility scores - - Highlight critical technical issues - - List blocked RFEs - - Provide actionable technical recommendations - - State readiness for implementation - -10. **Interactive Follow-up**: - - If issues found, ask if user wants to address them - - Suggest technical planning tasks (spikes, prototypes, research) - - Offer to help refine RFE technical details - - Recommend re-running `/rfe.breakdown` if major restructuring needed - -## Guidelines - -- Focus on technical feasibility and implementation readiness -- Be realistic about technical challenges and risks -- Identify skill gaps, resource needs, and infrastructure requirements -- Check that technical approaches are sound and well-thought-out -- Validate that dependencies are manageable -- Ensure testing strategies are comprehensive -- Flag underestimated complexity early -- Provide constructive technical guidance -- Recommend spikes or prototypes for high-risk areas -- Make clear technical recommendations for each RFE -- Balance thoroughness with pragmatism -- Consider both immediate implementation and long-term maintainability diff --git a/workflows/prd-rfe-workflow/.claude/commands/rfe.speedrun.md b/workflows/prd-rfe-workflow/.claude/commands/rfe.speedrun.md deleted file mode 100644 index ccc08af..0000000 --- a/workflows/prd-rfe-workflow/.claude/commands/rfe.speedrun.md +++ /dev/null @@ -1,247 +0,0 @@ ---- -description: Run the complete PRD-RFE workflow automatically from discovery to Jira submission, only pausing for critical questions. -displayName: rfe.speedrun -icon: ⚡ ---- - -## User Input - -```text -$ARGUMENTS -``` - -You **MUST** consider the user input before proceeding (if not empty). The user input should contain the initial product idea or problem statement. - -## Outline - -This command automates the entire PRD-RFE workflow from discovery through Jira submission. It runs each phase sequentially, making intelligent decisions and only pausing to ask simplified, critical questions when absolutely necessary. - -**Workflow Phases (in order)**: -1. `/prd.discover` - Product discovery -2. `/prd.requirements` - Requirements gathering -3. `/prd.create` - PRD creation -4. `/prd.review` - PRD review -5. `/prd.revise` - PRD revision (if needed, based on review) -6. `/rfe.breakdown` - RFE breakdown -7. `/rfe.review` - RFE review -8. `/rfe.revise` - RFE revision (if needed, based on review) -9. `/rfe.prioritize` - RFE prioritization -10. `/rfe.submit` - RFE submission to Jira - -## Execution Strategy - -### Phase 1: Discovery (`/prd.discover`) - -1. **Execute Discovery**: - - Run the discovery phase using the user's initial input - - Invoke collaborating agents: @parker-product_manager.md, @ryan-ux_researcher.md, @aria-ux_architect.md - - Generate `discovery.md` - - Make reasonable assumptions when information is missing - - Only ask questions if critical information is completely absent - -2. **Critical Questions (only if needed)**: - - "Who are the primary users?" (if not inferable from context) - - "What is the main problem being solved?" (if not clear from input) - - Maximum 2-3 questions total - -3. **Proceed automatically** to requirements phase - -### Phase 2: Requirements (`/prd.requirements`) - -1. **Execute Requirements Gathering**: - - Read `discovery.md` - - Invoke collaborating agents: @parker-product_manager.md, @ryan-ux_researcher.md, @olivia-product_owner.md, @aria-ux_architect.md - - Generate `requirements.md` - - Use discovery insights to create requirements - - Apply MoSCoW prioritization automatically - -2. **Critical Questions (only if needed)**: - - "Are there any specific technical constraints?" (if not mentioned) - - "What is the target timeline?" (if critical for prioritization) - - Maximum 1-2 questions total - -3. **Proceed automatically** to PRD creation - -### Phase 3: PRD Creation (`/prd.create`) - -1. **Execute PRD Creation**: - - Read `discovery.md` and `requirements.md` - - Invoke collaborating agents: @parker-product_manager.md, @ryan-ux_researcher.md, @terry-technical_writer.md, @casey-content_strategist.md - - Generate `prd.md` and `prd-checklist.md` - - Synthesize all information into comprehensive PRD - - Make reasonable assumptions for missing details - -2. **No questions** - proceed directly to review - -### Phase 4: PRD Review (`/prd.review`) - -1. **Execute PRD Review**: - - Read `prd.md` - - Invoke collaborating agents: @steve-ux_designer.md, @aria-ux_architect.md, @olivia-product_owner.md, @archie-architect.md - - Generate `prd-review-report.md` - - Assess quality, completeness, and feasibility - - Determine if prototype is needed - -2. **Critical Questions (only if needed)**: - - "Is a prototype needed before proceeding?" (if unclear from review) - - Maximum 1 question - -3. **Decision Point**: - - If review identifies critical issues → proceed to revision - - If review is satisfactory → proceed to RFE breakdown - -### Phase 5: PRD Revision (`/prd.revise`) - Conditional - -1. **Only execute if review identified critical issues**: - - Read `prd-review-report.md` - - Invoke collaborating agents: @parker-product_manager.md, @terry-technical_writer.md - - Update `prd.md` based on review feedback - - Address all critical issues automatically - - Make reasonable decisions on non-critical feedback - -2. **No questions** - proceed to RFE breakdown - -### Phase 6: RFE Breakdown (`/rfe.breakdown`) - -1. **Execute RFE Breakdown**: - - Read `prd.md` - - Invoke collaborating agents: @olivia-product_owner.md, @stella-staff_engineer.md, @archie-architect.md, @neil-test_engineer.md - - Generate `rfes.md` and individual RFE files in `rfe-tasks/` - - Break down PRD into implementable RFEs - - Size RFEs appropriately - - Identify dependencies automatically - -2. **No questions** - proceed to RFE review - -### Phase 7: RFE Review (`/rfe.review`) - -1. **Execute RFE Review**: - - Read `rfes.md` and RFE files - - Invoke collaborating agents: @stella-staff_engineer.md, @archie-architect.md, @neil-test_engineer.md, @emma-engineering_manager.md, @olivia-product_owner.md - - Review all RFEs for technical feasibility, testability, and capacity - - Assess architecture alignment - - Identify any critical blockers - -2. **Critical Questions (only if needed)**: - - "Are there any team capacity constraints?" (if not already known) - - Maximum 1 question - -3. **Decision Point**: - - If review identifies critical issues → proceed to revision - - If review is satisfactory → proceed to prioritization - -### Phase 8: RFE Revision (`/rfe.revise`) - Conditional - -1. **Only execute if review identified critical issues**: - - Read review feedback - - Invoke collaborating agents: @olivia-product_owner.md, @stella-staff_engineer.md, @neil-test_engineer.md - - Update RFE files based on review feedback - - Address technical concerns and refine scope - -2. **No questions** - proceed to prioritization - -### Phase 9: Prioritization (`/rfe.prioritize`) - -1. **Execute Prioritization**: - - Read `rfes.md` and `prd.md` - - Invoke collaborating agents: @parker-product_manager.md, @olivia-product_owner.md, @emma-engineering_manager.md - - Apply RICE or MoSCoW framework automatically - - Generate `prioritization.md` and optionally `roadmap-visual.md` - - Create implementation roadmap - -2. **Critical Questions (only if needed)**: - - "What is the target release date?" (if critical for roadmap) - - "Are there any business-critical deadlines?" (if not mentioned) - - Maximum 1-2 questions - -3. **Proceed automatically** to submission - -### Phase 10: RFE Submission (`/rfe.submit`) - -1. **Execute Submission**: - - Read `rfes.md` and all RFE files - - Invoke collaborating agents: @olivia-product_owner.md, @emma-engineering_manager.md, @parker-product_manager.md - - Check for Jira MCP availability - - If available: Create Jira tickets automatically - - If not available: Generate manual submission instructions - - Create `jira-tickets.md` (if Jira MCP available) - -2. **No questions** - complete workflow - -## Guidelines - -### Question Strategy -- **Minimize questions**: Only ask when information is absolutely critical and cannot be reasonably inferred -- **Batch questions**: If multiple questions are needed, ask them all at once -- **Use defaults**: Make reasonable assumptions and proceed when possible -- **Context-aware**: Use information from previous phases to answer questions automatically - -### Decision Making -- **Auto-proceed**: Move to next phase automatically unless critical blocker identified -- **Smart defaults**: Use industry best practices and common patterns -- **Review thresholds**: Only trigger revision phases if critical issues are found -- **Prioritization**: Use RICE framework by default, fall back to MoSCoW if data insufficient - -### Error Handling -- **Missing artifacts**: If a required artifact is missing, generate it with best available information -- **Agent unavailability**: Proceed with available agents, note limitations -- **Jira MCP unavailable**: Provide clear manual submission instructions -- **Critical blockers**: If a phase cannot proceed, pause and ask user, then continue - -### Progress Reporting -After each phase, provide a brief status update: -- Phase completed -- Key decisions made -- Artifacts created -- Next phase starting - -At completion, provide a comprehensive summary: -- All artifacts created -- Total RFEs generated -- Jira tickets created (or manual submission instructions) -- Next steps for the team - -## Completion Report Template - -```markdown -# Speedrun Workflow Complete ✅ - -## Summary -Successfully completed PRD-RFE workflow from discovery to Jira submission. - -## Artifacts Created -- discovery.md -- requirements.md -- prd.md -- prd-checklist.md -- prd-review-report.md -- rfes.md -- rfe-tasks/ (X individual RFE files) -- prioritization.md -- jira-tickets.md (or manual submission instructions) - -## Statistics -- Total RFEs: X -- High Priority: X -- Medium Priority: X -- Low Priority: X - -## Jira Status -- [ ] Tickets created automatically (X tickets) -- [ ] Manual submission required (see jira-tickets.md for instructions) - -## Next Steps -1. Review generated artifacts -2. [If manual submission] Create Jira tickets using provided instructions -3. Share PRD and RFEs with stakeholders -4. Begin sprint planning with prioritized RFEs -``` - -## Usage Notes - -- This command is designed for experienced users who want to quickly generate a complete PRD and RFE set -- It makes reasonable assumptions throughout to minimize interruptions -- Users can always run individual commands later to refine specific phases -- All artifacts are saved and can be reviewed/revised after speedrun completion -- The workflow can be paused at any critical question if user needs to gather information - diff --git a/workflows/prd-rfe-workflow/.claude/commands/rfe.submit.md b/workflows/prd-rfe-workflow/.claude/commands/rfe.submit.md deleted file mode 100644 index b2e182b..0000000 --- a/workflows/prd-rfe-workflow/.claude/commands/rfe.submit.md +++ /dev/null @@ -1,204 +0,0 @@ ---- -description: Submit RFEs to Jira for implementation planning and team assignment. -displayName: rfe.submit -icon: 🎫 ---- - -## User Input - -```text -$ARGUMENTS -``` - -You **MUST** consider the user input before proceeding (if not empty). - -## Outline - -This command submits RFEs to Jira for implementation planning. It should be run after `/rfe.breakdown` and optionally after `/rfe.prioritize`. - -**IMPORTANT: Agent Collaboration** - -You MUST proactively invoke the following collaborating agents to ensure proper RFE submission: - -1. **@olivia-product_owner.md** (from bullpen) - For backlog prioritization, sprint planning, and ticket structure -2. **@emma-engineering_manager.md** (from bullpen) - For team assignment, capacity allocation, and delivery coordination -3. **@parker-product_manager.md** - For roadmap alignment and stakeholder communication - -Invoke these agents at the start of the submission process. Work collaboratively with them to ensure tickets are properly structured, prioritized, and assigned. - -1. **Load Context**: - - Read `rfes.md` (RFE master list) - - Read all individual RFE files from `rfe-tasks/` directory - - Check if prioritization document exists (`prioritization.md`) - - Consider user input from $ARGUMENTS - -2. **Check Jira MCP Server Availability**: - - Attempt to detect if Jira MCP server is available - - If available, proceed with automated ticket creation (Step 3) - - If not available, provide manual submission instructions (Step 4) - -3. **Automated Jira Ticket Creation** (if Jira MCP available): - - For each RFE in the master list: - - a. **Read RFE File**: - - Load `rfe-tasks/RFE-XXX-[slug].md` - - Extract key information: - - RFE ID and title - - Summary - - Priority and size - - Acceptance criteria - - Dependencies - - User stories - - Technical approach (if available) - - b. **Create Jira Ticket**: - - Use Jira MCP server to create a ticket - - Map RFE fields to Jira fields: - - **Title**: `RFE-XXX: [RFE Title]` - - **Description**: - - Summary section - - Problem Statement - - Proposed Solution (high-level) - - Link to full RFE document - - **Issue Type**: "Story" or "Task" (or as configured) - - **Priority**: Map from RFE priority (High/Medium/Low → Jira priority levels) - - **Labels**: Add "RFE", RFE ID, and any relevant tags - - **Acceptance Criteria**: Include all acceptance criteria from RFE - - **Dependencies**: Link to prerequisite RFE tickets if they exist - - **Attachments**: Optionally attach the full RFE markdown file - - c. **Link Related Tickets**: - - If dependencies exist, create links between tickets - - Link tickets that are part of the same epic or phase - - d. **Create Epic or Parent Ticket** (if applicable): - - If RFEs are grouped by epic, create or link to epic tickets - - Set up parent-child relationships if needed - - e. **Report Ticket Creation**: - - Document created ticket keys (e.g., PROJ-123, PROJ-124) - - Create a mapping file: `jira-tickets.md` with: - ```markdown - # Jira Ticket Mapping - - | RFE ID | Jira Ticket | Title | Status | - |--------|------------|-------|--------| - | RFE-001 | PROJ-123 | [Title] | Created | - | RFE-002 | PROJ-124 | [Title] | Created | - ``` - -4. **Manual Submission Instructions** (if Jira MCP not available): - - Provide clear instructions to the user: - - ```markdown - ## Manual Jira Ticket Submission - - The Jira MCP server is not currently available. Please manually create Jira tickets using the RFE files. - - ### RFE Files Location - - All RFE files are located in: - ``` - artifacts/rfe-tasks/ - ``` - - ### RFE Master List - - The complete list of RFEs with summaries is in: - ``` - artifacts/rfes.md - ``` - - ### Steps to Create Jira Tickets - - 1. **Open Jira** and navigate to your project board - - 2. **For each RFE file** in `rfe-tasks/`: - - a. Click "Create" to create a new ticket - - b. **Set Ticket Fields**: - - **Title**: Copy the RFE title (e.g., "RFE-001: [Title]") - - **Issue Type**: Select "Story" or "Task" - - **Priority**: Map from RFE priority - - High → Highest/High - - Medium → Medium - - Low → Low/Lowest - - c. **Description**: Copy and paste from the RFE file: - - Summary section - - Problem Statement - - Proposed Solution (Core Requirements) - - User Stories - - d. **Acceptance Criteria**: Copy all acceptance criteria from the RFE file - - e. **Attachments**: Attach the full RFE markdown file (`RFE-XXX-[slug].md`) - - f. **Labels**: Add "RFE" and the RFE ID (e.g., "RFE-001") - - g. **Dependencies**: - - If the RFE has prerequisites, link to those tickets - - Reference the "Prerequisite RFEs" section in the RFE file - - h. **Save** the ticket - - 3. **Link Related Tickets**: - - If RFEs have dependencies, create links between tickets - - Use Jira's "Links" feature to connect prerequisite and blocking tickets - - 4. **Create Epics** (if applicable): - - If RFEs are grouped by epic (check `rfes.md` for phase/epic groupings) - - Create epic tickets and link related RFE tickets to them - - 5. **Verify Submission**: - - Check that all RFEs from `rfes.md` have corresponding Jira tickets - - Verify dependencies are properly linked - - Confirm acceptance criteria are included - - ### Quick Reference - - - **Total RFEs**: Check `rfes.md` for count - - **RFE Files**: `rfe-tasks/RFE-*.md` - - **Prioritization**: If available, check `prioritization.md` for recommended order - ``` - -5. **Validate Submission**: - - Verify all RFEs have been submitted (check count matches master list) - - Confirm critical RFEs (P0/high priority) are included - - Check that dependencies are properly documented or linked - -6. **Report Completion**: - - Summary of submitted RFEs - - Ticket keys or file locations (depending on method) - - Next steps for the team (sprint planning, assignment, etc.) - -## Guidelines - -- **Jira MCP Integration**: When available, use the MCP server to automate ticket creation and ensure consistency -- **Ticket Format**: Maintain consistency in ticket titles, descriptions, and field mappings -- **Dependencies**: Always properly link dependent tickets to maintain traceability -- **Acceptance Criteria**: Include all acceptance criteria from RFE files in Jira tickets -- **Attachments**: Attach full RFE markdown files to tickets for complete context -- **Epic Organization**: Group related RFEs under epics when appropriate -- **Manual Fallback**: Provide clear, actionable instructions when automation isn't available - -## Error Handling - -- If Jira MCP is available but connection fails: - - Report the error clearly - - Provide manual submission instructions as fallback - - Suggest checking Jira credentials or MCP server configuration - -- If RFE files are missing: - - Report which RFEs are missing - - Suggest running `/rfe.breakdown` first if needed - - Provide list of expected RFE files - -- If ticket creation partially fails: - - Report which tickets were created successfully - - Report which tickets failed - - Provide instructions for manually creating the failed tickets - diff --git a/workflows/prd-rfe-workflow/.claude/templates/rfe-template.md b/workflows/prd-rfe-workflow/.claude/templates/feature-template.md similarity index 84% rename from workflows/prd-rfe-workflow/.claude/templates/rfe-template.md rename to workflows/prd-rfe-workflow/.claude/templates/feature-template.md index 0c1857e..1eedb82 100644 --- a/workflows/prd-rfe-workflow/.claude/templates/rfe-template.md +++ b/workflows/prd-rfe-workflow/.claude/templates/feature-template.md @@ -1,11 +1,11 @@ -# RFE Template - Red Hat Format +# Feature Template - Red Hat Format -This template provides a standardized format for creating Request for Enhancement (RFE) documents that conform to Red Hat's RFE structure. Use this template when generating individual RFE files. +This template provides a standardized format for creating Feature documents that conform to Red Hat's Feature structure. Use this template when generating individual Feature files. ## Template Structure ```markdown -# RFE-XXX: [Title] +# Feature-XXX: [Title] **Status**: Not Started **Priority**: [High/Medium/Low] @@ -39,7 +39,7 @@ Example: "Extend the [component/feature] to [action], providing [target users] w ## Problem Statement -[Clearly articulate the problem(s) this RFE addresses. Focus on user pain points and business impact. Use specific, measurable language when possible.] +[Clearly articulate the problem(s) this Feature addresses. Focus on user pain points and business impact. Use specific, measurable language when possible.] [Target User Persona] needs [capability/visibility/functionality] because [reason/impact]. The current [system/UI/feature] provides no indication of: @@ -71,7 +71,7 @@ Example: "Extend the [component/feature] to [action], providing [target users] w ### UI/UX Enhancements -[If this RFE involves user interface changes, describe the enhancements in detail.] +[If this Feature involves user interface changes, describe the enhancements in detail.] #### New Components/Columns/Views - **[Component Name]**: [Description] @@ -125,7 +125,7 @@ Example: "Extend the [component/feature] to [action], providing [target users] w ## Acceptance Criteria -[Testable, measurable criteria that define when this RFE is complete. Use checkboxes for tracking.] +[Testable, measurable criteria that define when this Feature is complete. Use checkboxes for tracking.] - [ ] [Criterion 1 - specific and testable] - [ ] [Criterion 2 - specific and testable] @@ -140,19 +140,19 @@ Example: "Extend the [component/feature] to [action], providing [target users] w - [Deliverable 3] ### Out of Scope -- [What is explicitly NOT included in this RFE] -- [Future enhancements that may be separate RFEs] +- [What is explicitly NOT included in this Feature] +- [Future enhancements that may be separate Features] - [Related features that are handled elsewhere] ## Dependencies -### Prerequisite RFEs -- RFE-XXX: [What must be completed first] -- RFE-YYY: [What must be completed first] +### Prerequisite Features +- Feature-XXX: [What must be completed first] +- Feature-YYY: [What must be completed first] -### Blocks RFEs -- RFE-AAA: [What depends on this RFE] -- RFE-BBB: [What depends on this RFE] +### Blocks Features +- Feature-AAA: [What depends on this Feature] +- Feature-BBB: [What depends on this Feature] ### External Dependencies - [System/API/Service]: [Description of dependency] @@ -161,7 +161,7 @@ Example: "Extend the [component/feature] to [action], providing [target users] w ## Success Criteria -[Measurable outcomes that indicate this RFE has achieved its goals. Should align with the problem statement and user stories.] +[Measurable outcomes that indicate this Feature has achieved its goals. Should align with the problem statement and user stories.] - **Visibility**: [What users can now see/understand] - **Performance**: [Performance requirements or improvements] @@ -218,7 +218,7 @@ Example: "Extend the [component/feature] to [action], providing [target users] w ## Definition of Done -[Checklist of items that must be complete for this RFE to be considered done] +[Checklist of items that must be complete for this Feature to be considered done] - [ ] All acceptance criteria met - [ ] Unit tests written and passing @@ -233,7 +233,7 @@ Example: "Extend the [component/feature] to [action], providing [target users] w ## Usage Guidelines -When generating RFEs using this template: +When generating Features using this template: 1. **Summary**: Keep it concise (1-3 sentences). Focus on what's being extended/added and who benefits. @@ -249,16 +249,15 @@ When generating RFEs using this template: 7. **Success Criteria**: Should align with problem statement and be measurable. -8. **Adapt as Needed**: Not all sections are required for every RFE. Omit sections that don't apply, but maintain the overall structure. +8. **Adapt as Needed**: Not all sections are required for every Feature. Omit sections that don't apply, but maintain the overall structure. ## Extensions This template can be extended with additional sections as needed: - **Design Mockups**: Links to Figma, Miro, or design artifacts -- **API Specifications**: If the RFE involves API changes +- **API Specifications**: If the Feature involves API changes - **Database Schema**: If data model changes are required - **Migration Plan**: If existing data needs to be migrated - **Rollout Strategy**: If phased rollout is planned -- **Monitoring & Observability**: What metrics/logs will be added - +- **Monitoring & Observability**: What metrics/logs will be added \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/README.md b/workflows/prd-rfe-workflow/README.md index eb58a99..b6051b0 100644 --- a/workflows/prd-rfe-workflow/README.md +++ b/workflows/prd-rfe-workflow/README.md @@ -1,16 +1,16 @@ -# Create PRDs & RFEs +# Create PRDs & Features -A comprehensive workflow for creating Product Requirements Documents (PRDs) and systematically breaking them down into actionable Request for Enhancement (RFE) items. +A comprehensive workflow for creating Product Requirements Documents (PRDs) and systematically breaking them down into actionable Feature items. -This workflow is deisned to be run on [Ambient Code Platform](https://github.com/ambient-code/platform). +This workflow is deisned to be run on [Ambient Code Platform](https://github.com/ambient-code/platform). ## Who this is for -**Product Managers** who want to leverage agents in the creation of comprehensive, well-defined, data-informed PRDs and RFEs. The goal is to generate PRDs and RFEs that are more likely to be accepted by a Senior Engineer or Architect for implementation. +**Product Managers** who want to leverage agents in the creation of comprehensive, well-defined, data-informed PRDs and Features. The goal is to generate PRDs and Features that are more likely to be accepted by a Senior Engineer or Architect for implementation. ## Workflow -The creation of a PRD and subsequent refinements of RFEs associated with that PRD follow a general workflow that starts with discovery, goes through two refinement loops, and utimately exports RFE definitions to Jira. +The creation of a PRD and subsequent refinements of Features associated with that PRD follow a general workflow that starts with discovery, goes through two refinement loops, and utimately exports Feature definitions to Jira. ```mermaid flowchart LR @@ -18,27 +18,27 @@ flowchart LR UXR[(UXR MCP)] -.-> A UF[(User-uploaded files)] -.-> A CODE[(Code)] -.-> A - - A[prd.discover] --> REQ[prd.requirements] + + A[prd.discover] --> REQ[prd.rfe] REQ --> review_loop - + subgraph review_loop["PRD Review Loop"] B[prd.create] --> C[prd.review] C --> D[prd.revise] D --> B end - - subgraph rfe_loop["RFE Review Loop"] - E[rfe.breakdown] --> F[rfe.review] - F --> G[rfe.revise] + + subgraph feature_loop["Feature Review Loop"] + E[feature.breakdown] --> F[feature.review] + F --> G[feature.revise] G --> E end - - review_loop --> rfe_loop - rfe_loop --> PRIO[rfe.prioritize] - PRIO --> H[rfe.submit] + + review_loop --> feature_loop + feature_loop --> PRIO[feature.prioritize] + PRIO --> H[feature.submit] H -.-> JIRA[Jira] - + style GD fill:#999,stroke:#666,color:#fff style UXR fill:#999,stroke:#666,color:#fff style UF fill:#999,stroke:#666,color:#fff @@ -48,26 +48,26 @@ flowchart LR ### Slash Commands -The workflow is accessible through slash commands which enable the user to keep the agents on track. Some commands have prerequisites. For example `/rfe.breakdown` which breaks a PRD down into RFEs, requires the existance of a PRD document. +The workflow is accessible through slash commands which enable the user to keep the agents on track. Some commands have prerequisites. For example `/feature.breakdown` which breaks a PRD down into Features, requires the existance of a PRD document. -**Quick Start**: Use `/rfe.speedrun` to automatically run the entire workflow from discovery to Jira submission, only pausing for critical questions. +**Quick Start**: Use `/feature.speedrun` to automatically run the entire workflow from discovery to Jira submission, only pausing for critical questions. **Individual Commands**: 1. [`prd.discover`](#1-prddiscover) - Product discovery -2. [`prd.requirements`](#2-prdrequirements) - Define precise requirements +2. [`prd.rfe`](#2-prdrfe) - Define precise requirements 3. [`prd.create`](#3-prdcreate) - Draft or update PRD 4. [`prd.review`](#4-prdreview) - PRD review by senior engineer and architect agents. 5. [`prd.revise`](#5-prdrevise) - Revise PRD based on feedback or new data -6. [`rfe.breakdown`](#6-rfebreakdown) - Breakdown a PRD into scoped RFEs -7. [`rfe.review`](#7-rfereview) - Individual RFE review by senior engineer and architect agents. -8. [`rfe.revise`](#8-rferevise) - RFE Revision -9. [`rfe.prioritize`](#9-rfeprioritize) - Prioritize RFEs and create implementation roadmap -10. [`rfe.submit`](#10-rfesubmit) - RFE formatting and submission to Jira +6. [`feature.breakdown`](#6-featurebreakdown) - Breakdown a PRD into scoped Features +7. [`feature.review`](#7-featurereview) - Individual Feature review by senior engineer and architect agents. +8. [`feature.revise`](#8-featurerevise) - Feature Revision +9. [`feature.prioritize`](#9-featureprioritize) - Prioritize Features and create implementation roadmap +10. [`feature.submit`](#10-featuresubmit) - Feature formatting and submission to Jira **Meta-Commands**: -- [`rfe.speedrun`](#rfespeedrun) - Automatically run the complete workflow from discovery to Jira submission, only pausing for critical questions +- [`feature.speedrun`](#featurespeedrun) - Automatically run the complete workflow from discovery to Jira submission, only pausing for critical questions - [`prd.sources`](#prdsources) - List all data sources that informed the PRD creation, including documents, code references, research, and external sources --- @@ -98,7 +98,7 @@ The workflow is accessible through slash commands which enable the user to keep --- -### 2. `prd.requirements` +### 2. `prd.rfe` **Purpose**: Define precise requirements **Collaborating Agents**: @@ -116,7 +116,7 @@ The workflow is accessible through slash commands which enable the user to keep - Clearly define scope and out-of-scope items **Artifacts Created**: -- `artifacts/requirements.md` - Detailed product requirements document with business requirements, user stories, functional and non-functional requirements +- `artifacts/rfe.md` - Detailed product requirements document with business requirements, user stories, functional and non-functional requirements --- @@ -179,8 +179,8 @@ The workflow is accessible through slash commands which enable the user to keep --- -### 6. `rfe.breakdown` -**Purpose**: Breakdown a PRD into scoped RFEs +### 6. `feature.breakdown` +**Purpose**: Breakdown a PRD into scoped Features **Collaborating Agents**: - **@olivia-product_owner.md** (bullpen) - Backlog management, story decomposition, acceptance criteria @@ -189,20 +189,20 @@ The workflow is accessible through slash commands which enable the user to keep - **@neil-test_engineer.md** (bullpen) - Testability assessment, automation requirements, cross-component impact **Key Actions**: -- Decompose PRD into implementable RFEs -- Define clear acceptance criteria for each RFE +- Decompose PRD into implementable Features +- Define clear acceptance criteria for each Feature - Identify technical dependencies and risks -- Size RFEs and assess testing requirements +- Size Features and assess testing requirements **Artifacts Created**: -- `artifacts/rfes.md` - RFE master list with overview, summary, and detailed RFE descriptions -- `artifacts/rfe-tasks/` - Directory containing individual RFE files - - `RFE-001-[slug].md`, `RFE-002-[slug].md`, etc. - Individual RFE documents following Red Hat RFE format +- `artifacts/features.md` - Feature master list with overview, summary, and detailed Feature descriptions +- `artifacts/feature-tasks/` - Directory containing individual Feature files + - `Feature-001-[slug].md`, `Feature-002-[slug].md`, etc. - Individual Feature documents following Red Hat Feature format --- -### 7. `rfe.review` -**Purpose**: Individual RFE review by senior engineer and architect agents. +### 7. `feature.review` +**Purpose**: Individual Feature review by senior engineer and architect agents. **Collaborating Agents**: - **@stella-staff_engineer.md** - Technical feasibility, implementation complexity, risk assessment @@ -218,12 +218,12 @@ The workflow is accessible through slash commands which enable the user to keep - Ensure architecture alignment **Artifacts Created**: -- RFE review feedback and recommendations (may update individual RFE files in `artifacts/rfe-tasks/`) +- Feature review feedback and recommendations (may update individual Feature files in `artifacts/feature-tasks/`) --- -### 8. `rfe.revise` -**Purpose**: RFE Revision +### 8. `feature.revise` +**Purpose**: Feature Revision **Collaborating Agents**: - **@olivia-product_owner.md** (bullpen) - Story refinement, scope adjustments @@ -237,12 +237,12 @@ The workflow is accessible through slash commands which enable the user to keep - Enhance testability of requirements **Artifacts Created**: -- Updates to individual RFE files in `artifacts/rfe-tasks/` - Revised RFEs based on review feedback +- Updates to individual Feature files in `artifacts/feature-tasks/` - Revised Features based on review feedback --- -### 9. `rfe.prioritize` -**Purpose**: Prioritize RFEs using various frameworks and create an implementation roadmap +### 9. `feature.prioritize` +**Purpose**: Prioritize Features using various frameworks and create an implementation roadmap **Collaborating Agents**: - **@parker-product_manager.md** - RICE scoring, business value assessment, ROI analysis, market strategy alignment @@ -251,11 +251,11 @@ The workflow is accessible through slash commands which enable the user to keep **Key Actions**: - Apply prioritization frameworks (MoSCoW, RICE, Value vs Effort, Kano Model) -- Score and rank RFEs based on business value and user impact +- Score and rank Features based on business value and user impact - Create implementation roadmap with phases/releases - Define dependency-driven sequence - Perform risk-adjusted prioritization -- Map RFEs to business goals and user needs +- Map Features to business goals and user needs - Generate recommendations for implementation order **Artifacts Created**: @@ -264,11 +264,11 @@ The workflow is accessible through slash commands which enable the user to keep --- -### 10. `rfe.submit` -**Purpose**: RFE formatting and submission to Jira +### 10. `feature.submit` +**Purpose**: Feature formatting and submission to Jira **Data Connections**: -- **Jira MCP** - When available, automatically creates Jira tickets from RFE files with proper field mapping, dependencies, and attachments +- **Jira MCP** - When available, automatically creates Jira tickets from Feature files with proper field mapping, dependencies, and attachments **Collaborating Agents**: - **@olivia-product_owner.md** (bullpen) - Backlog prioritization, sprint planning, ticket structure @@ -276,21 +276,21 @@ The workflow is accessible through slash commands which enable the user to keep - **@parker-product_manager.md** - Roadmap alignment, stakeholder communication **Key Actions**: -- **If Jira MCP available**: Automatically create Jira tickets from RFE files - - Map RFE fields to Jira fields (title, description, priority, acceptance criteria) +- **If Jira MCP available**: Automatically create Jira tickets from Feature files + - Map Feature fields to Jira fields (title, description, priority, acceptance criteria) - Link dependent tickets - - Attach RFE markdown files + - Attach Feature markdown files - Create ticket mapping document - **If Jira MCP not available**: Provide manual submission instructions - - Direct users to `artifacts/rfe-tasks/` directory + - Direct users to `artifacts/feature-tasks/` directory - Provide step-by-step instructions for creating tickets - Include field mapping guidance -- Prioritize RFEs in backlog +- Prioritize Features in backlog - Assign to appropriate teams - Align with product roadmap **Artifacts Created**: -- `artifacts/jira-tickets.md` - Jira ticket mapping document with RFE ID to Jira ticket key mappings (when Jira MCP is available) +- `artifacts/jira-tickets.md` - Jira ticket mapping document with Feature ID to Jira ticket key mappings (when Jira MCP is available) ## Quick Start @@ -325,4 +325,4 @@ This workflow is part of the Ambient Code Platform Workflows collection. --- -**Happy Product Planning! 📋→🚀** +**Happy Product Planning! 📋→🚀** \ No newline at end of file diff --git a/workflows/prd-rfe-workflow/workflow-diagram.md b/workflows/prd-rfe-workflow/workflow-diagram.md index a8eb462..1bfbd7d 100644 --- a/workflows/prd-rfe-workflow/workflow-diagram.md +++ b/workflows/prd-rfe-workflow/workflow-diagram.md @@ -5,7 +5,7 @@ flowchart LR UF[(User-uploaded files)] -.-> A CODE[(Code)] -.-> A - A[prd.discover] --> REQ[prd.requirements] + A[prd.discover] --> REQ[prd.rfe] REQ --> review_loop subgraph review_loop["PRD Review Loop"] @@ -14,15 +14,15 @@ flowchart LR D --> B end - subgraph rfe_loop["RFE Review Loop"] - E[rfe.breakdown] --> F[rfe.review] - F --> G[rfe.revise] + subgraph feature_loop["Feature Review Loop"] + E[feature.breakdown] --> F[feature.review] + F --> G[feature.revise] G --> E end - - review_loop --> rfe_loop - rfe_loop --> PRIO[rfe.prioritize] - PRIO --> H[rfe.submit] + + review_loop --> feature_loop + feature_loop --> PRIO[feature.prioritize] + PRIO --> H[feature.submit] H -.-> JIRA[Jira] style GD fill:#999,stroke:#666,color:#fff