@vfarcic/dot-ai 0.36.0 → 0.38.0

package/shared-prompts/prd-create.md

@@ -0,0 +1,172 @@
+---
+name: prd-create
+description: Create documentation-first PRDs that guide development through user-facing content
+category: project-management
+---
+
+# PRD Creation Slash Command
+
+## Instructions
+
+You are helping create a documentation-first Product Requirements Document (PRD) for a new feature. This process involves three components:
+
+1. **GitHub Issue**: Short, immutable concept description that links to the detailed PRD
+2. **PRD File**: Project management document with milestone tracking, progress logs, and references to documentation
+3. **Documentation Updates**: Actual user-facing content written directly into documentation files with PRD traceability comments
+
+## Process
+
+### Step 1: Understand the Feature Concept
+Ask the user to describe the feature idea to understand the core concept and scope.
+
+### Step 2: Create GitHub Issue FIRST
+Create the GitHub issue immediately to get the issue ID. This ID is required for proper PRD file naming.
+
+### Step 3: Create PRD File with Correct Naming
+Create the PRD file using the actual GitHub issue ID: `prds/[issue-id]-[feature-name].md`
+
+### Step 4: Update GitHub Issue with PRD Link
+Add the PRD file link to the GitHub issue description now that the filename is known.
+
+### Step 5: Analyze Existing Documentation Architecture
+BEFORE making any documentation changes, perform systematic analysis of ALL documentation files:
+
+**A. Discover All Documentation Files**
+```bash
+# Find all documentation files (adapt for your project's documentation format)
+find . -name "*.md" -not -path "*/node_modules/*" | sort
+
+# Or for other formats:
+find . -name "*.rst" -o -name "*.txt" -o -name "*.adoc" | sort
+```
+
+**B. Identify Feature/Capability References**
+```bash  
+# Search for existing feature lists and capability references
+grep -r -i "capability\|feature\|guide.*\|provides.*\|main.*\|Key.*Features" docs/ README*
+
+# Look for documentation indexes and cross-reference patterns
+grep -r "- \*\*\[.*\]\|### .*Guide\|## Documentation" docs/ README*
+```
+
+**C. Use Task Tool for Pattern Analysis**
+Use the Task tool to analyze ALL discovered files to understand:
+- Current documentation structure and patterns
+- Consistent section naming conventions  
+- How features are introduced and described
+- Whether there are verification/setup patterns for features
+- Cross-reference architecture between docs
+- Tone and style consistency
+- Documentation indexes/lists that should include new content
+
+### Step 6: Plan Complete Documentation Changes
+Based on the analysis, create comprehensive checklist of ALL documentation files that need updates:
+
+**Create systematic checklist:**
+- [ ] New documentation files to create
+- [ ] Existing files with capability/feature lists that need updates
+- [ ] Documentation indexes (like README.md sections) that should include new content  
+- [ ] Setup/configuration guides that need new sections
+- [ ] Cross-reference sections ("See Also") that should link to new content
+- [ ] Any files that mention related functionality and should acknowledge new capability
+
+**Document the rationale for each update to ensure nothing is missed.**
+
+### Step 7: Write Documentation Content First
+Create/update ALL user-facing documentation content with `<!-- PRD-[issue-id] -->` comments for traceability, following established patterns.
+
+### Step 8: Create PRD as Project Tracker
+Work through the PRD template focusing on project management, milestone tracking, and references to the documentation content.
+
+**Key Principle**: Focus on 5-10 major milestones rather than exhaustive task lists. Each milestone should represent meaningful progress that can be clearly validated.
+
+**Good Milestones Examples:**
+- [ ] Core functionality implemented and working
+- [ ] Documentation complete and tested
+- [ ] Integration with existing systems working
+- [ ] Feature ready for user testing
+- [ ] Feature launched and available
+
+**Avoid Micro-Tasks:**
+- ❌ Update README.md file
+- ❌ Write test for function X
+- ❌ Fix typo in documentation
+- ❌ Individual file modifications
+
+**Milestone Characteristics:**
+- **Meaningful**: Represents significant progress toward completion
+- **Testable**: Clear success criteria that can be validated
+- **User-focused**: Relates to user value or feature capability
+- **Manageable**: Can be completed in reasonable timeframe
+
+## GitHub Issue Template (Keep Short & Stable)
+
+**Initial Issue Creation (without PRD link):**
+```markdown
+## PRD: [Feature Name]
+
+**Problem**: [1-2 sentence problem description]
+
+**Solution**: [1-2 sentence solution overview]
+
+**Detailed PRD**: Will be added after PRD file creation
+
+**Priority**: [High/Medium/Low]
+```
+
+**Issue Update (after PRD file created):**
+```markdown
+## PRD: [Feature Name]
+
+**Problem**: [1-2 sentence problem description]
+
+**Solution**: [1-2 sentence solution overview]
+
+**Detailed PRD**: See [prds/[actual-issue-id]-[feature-name].md](./prds/[actual-issue-id]-[feature-name].md)
+
+**Priority**: [High/Medium/Low]
+```
+
+## Discussion Guidelines
+
+### Documentation-First Planning Questions:
+1. **Architecture Analysis**: "What are the existing documentation patterns and structures I need to follow?"
+2. **User Experience**: "Walk me through the complete user journey - what will they read and do?"
+3. **Documentation Impact**: "Which existing docs need updates? What new docs are needed?"
+4. **Content Planning**: "What specific examples, commands, and workflows need to be documented?"
+5. **Cross-File Story**: "How does the user story flow across multiple documentation files?"
+6. **Pattern Consistency**: "How do other features handle setup, verification, and cross-references?"
+7. **Testable Claims**: "What commands and examples can be automatically tested to ensure accuracy?"
+8. **Implementation Phases**: "How can we deliver value incrementally through documentation updates?"
+9. **Terminology Consistency**: "How do we ensure terminology and examples are consistent across ALL affected files?"
+10. **Traceability**: "How will we track which documentation changes relate to this feature?"
+
+### Content Creation Process:
+1. **Analyze Documentation Architecture**: Use Task tool to understand existing patterns across ALL docs
+2. **Map Complete Documentation Changes**: Identify all files that need updates (don't miss any!)
+3. **Write User-Facing Content**: Create actual documentation content with examples following established patterns
+4. **Add Traceability**: Include `<!-- PRD-[issue-id] -->` comments in documentation
+5. **Update ALL Affected Files**: Ensure every file mentioned in PRD documentation map gets updated
+6. **Plan Implementation**: Break down development tasks that enable documented functionality
+7. **Validation Strategy**: Ensure all documented claims can be automatically tested
+
+### Discussion Tips:
+- **Clarify ambiguity**: If something isn't clear, ask follow-up questions until you understand
+- **Challenge assumptions**: Help the user think through edge cases, alternatives, and unintended consequences
+- **Prioritize ruthlessly**: Help distinguish between must-have and nice-to-have based on user impact
+- **Think about users**: Always bring the conversation back to user value, experience, and outcomes
+- **Consider feasibility**: While not diving into implementation details, ensure scope is realistic
+- **Focus on major milestones**: Create 5-10 meaningful milestones rather than exhaustive micro-tasks
+- **Think cross-functionally**: Consider impact on different teams, systems, and stakeholders
+
+## Workflow
+
+1. **Concept Discussion**: Get the basic idea and validate the need
+2. **Create GitHub Issue FIRST**: Short, stable concept description to get issue ID
+3. **Create PRD File**: Detailed document using actual issue ID: `prds/[issue-id]-[feature-name].md`
+4. **Update GitHub Issue**: Add link to PRD file now that filename is known
+5. **Section-by-Section Discussion**: Work through each template section systematically
+6. **Milestone Definition**: Define 5-10 major milestones that represent meaningful progress
+7. **Review & Validation**: Ensure completeness and clarity
+
+**CRITICAL**: Steps 2-4 must happen in this exact order to avoid the chicken-and-egg problem of needing the issue ID for the filename.

package/shared-prompts/prd-done.md

@@ -0,0 +1,53 @@
+---
+name: prd-done
+description: Complete PRD implementation workflow - create branch, push changes, create PR, merge, and close issue
+category: project-management
+---
+
+# Complete PRD Implementation
+
+Complete the PRD implementation workflow including branch management, pull request creation, and issue closure.
+
+## Workflow Steps
+
+### 1. Pre-Completion Validation
+- [ ] **All PRD checkboxes completed**: Verify every requirement is implemented and tested
+- [ ] **All tests passing**: Run `npm test` to ensure quality standards
+- [ ] **Documentation updated**: All user-facing docs reflect implemented functionality
+- [ ] **No outstanding blockers**: All dependencies resolved and technical debt addressed
+
+### 2. Branch and Commit Management
+- [ ] **Create feature branch**: `git checkout -b feature/prd-[issue-id]-[feature-name]`
+- [ ] **Commit all changes**: Ensure all implementation work is committed
+- [ ] **Clean commit history**: Squash or organize commits for clear history
+- [ ] **Push to remote**: `git push -u origin feature/prd-[issue-id]-[feature-name]`
+
+### 3. Pull Request Creation
+- [ ] **Create PR**: Use `gh pr create` with comprehensive description
+- [ ] **Link to PRD**: Reference the original issue and PRD file
+- [ ] **Review checklist**: Include testing, documentation, and quality confirmations
+- [ ] **Request reviews**: Assign appropriate team members for code review
+
+### 4. Review and Merge Process
+- [ ] **Check PR status**: Use `gh pr view [pr-number]` to check for any ongoing reviews or processes
+- [ ] **Wait for completion**: Do NOT merge if PR comments indicate reviews, checks, or processes are still in progress
+- [ ] **Address review feedback**: Make any required changes from code review
+- [ ] **Verify all checks pass**: Ensure all CI/CD, tests, and automated processes are complete and passing
+- [ ] **Merge to main**: Complete the pull request merge only after all feedback addressed and processes complete
+- [ ] **Verify deployment**: Ensure feature works in production environment
+- [ ] **Monitor for issues**: Watch for any post-deployment problems
+
+### 5. Issue Closure
+- [ ] **Update PRD status**: Mark PRD as "Complete" with completion date
+- [ ] **Close GitHub issue**: Add final completion comment and close
+- [ ] **Archive artifacts**: Save any temporary files or testing data if needed
+- [ ] **Team notification**: Announce feature completion to relevant stakeholders
+
+## Success Criteria
+✅ **Feature is live and functional**  
+✅ **All tests passing in production**  
+✅ **Documentation is accurate and complete**  
+✅ **PRD issue is closed with completion summary**  
+✅ **Team is notified of feature availability**
+
+The PRD implementation is only considered done when users can successfully use the feature as documented.

package/shared-prompts/prd-next.md

@@ -0,0 +1,247 @@
+---
+name: prd-next
+description: Analyze existing PRD to identify and recommend the single highest-priority task to work on next
+category: project-management
+---
+
+# PRD Next - Work On the Next Task
+
+## Instructions
+
+You are helping analyze an existing Product Requirements Document (PRD) to suggest the single highest-priority task to work on next, then discuss its design if the user confirms they want to work on it.
+
+## Process Overview
+
+1. **Check Context Clarity** - Determine if PRD is obvious from recent conversation
+2. **Auto-Detect Target PRD** - If context unclear, intelligently determine which PRD to analyze
+3. **Analyze Current Implementation** - Understand what's implemented vs what's missing (skip if recent context available)
+4. **Identify the Single Best Next Task** - Find the one task that should be worked on next
+5. **Present Recommendation** - Give clear rationale and wait for confirmation
+6. **Design Discussion** - If confirmed, dive into implementation design details
+
+## Step 0: Context Awareness Check
+
+**FIRST: Check if PRD context is already clear from recent conversation:**
+
+**Skip detection/analysis if recent conversation shows:**
+- **Recent PRD work discussed** - "We just worked on PRD 29", "Just completed PRD update", etc.
+- **Specific PRD mentioned** - "PRD #X", "MCP Prompts PRD", etc.
+- **PRD-specific commands used** - Recent use of `prd-update-progress`, `prd-start` with specific PRD
+- **Clear work context** - Discussion of specific features, tasks, or requirements for a known PRD
+
+**If context is clear:**
+- Skip to Step 6 (Single Task Recommendation) using the known PRD 
+- Use conversation history to understand current state and recent progress
+- Proceed directly with task recommendation based on known PRD status
+
+**If context is unclear:**
+- Continue to Step 1 (PRD Detection) for full analysis
+
+## Step 1: Smart PRD Detection (Only if Context Unclear)
+
+**Auto-detect the target PRD using these context clues (in priority order):**
+
+1. **Git Branch Analysis** - Check current branch name for PRD patterns:
+   - `feature/prd-12-*` → PRD 12
+   - `prd-13-*` → PRD 13
+   - `feature/prd-*` → Extract PRD number
+
+2. **Recent Git Commits** - Look at recent commit messages for PRD references:
+   - "fix: PRD 12 documentation" → PRD 12
+   - "feat: implement prd-13 features" → PRD 13
+
+3. **Git Status Analysis** - Check modified/staged files for PRD clues:
+   - Modified `prds/12-*.md` → PRD 12
+   - Changes in feature-specific directories
+
+4. **Available PRDs Discovery** - List all PRDs in `prds/` directory:
+   - `prds/12-documentation-testing.md`
+   - `prds/13-cicd-documentation-testing.md`
+
+5. **Fallback to User Choice** - Only if context detection fails, ask user to specify
+
+**PRD Detection Implementation:**
+```bash
+# Use these tools to gather context:
+# 1. Check git branch: gitStatus shows current branch
+# 2. Check git status: Look for modified PRD files  
+# 3. List PRDs: Use LS or Glob to find prds/*.md files
+# 4. Recent commits: Use Bash 'git log --oneline -n 5' for recent context
+```
+
+**Detection Logic:**
+- **High Confidence**: Branch name matches PRD pattern (e.g., `feature/prd-12-documentation-testing`)
+- **Medium Confidence**: Modified PRD files in git status or recent commits mention PRD
+- **Low Confidence**: Multiple PRDs available, use heuristics (most recent, largest)
+- **No Context**: Present available options to user
+
+**Example Detection Outputs:**
+```markdown
+🎯 **Auto-detected PRD 12** (Documentation Testing)
+- Branch: `feature/prd-12-documentation-testing` ✅
+- Modified files: `prds/12-documentation-testing.md` ✅
+- Recent commits mention PRD 12 features ✅
+```
+
+**Once PRD is identified:**
+- Read the PRD file from `prds/[issue-id]-[feature-name].md`
+- Analyze completion status across all sections
+- Identify patterns in completed vs remaining work
+
+## Step 2: Documentation & Implementation Analysis (Only if Context Unclear)
+
+Before assessing task priorities, analyze both the documented specifications and current implementation state:
+
+### Documentation Analysis (Documentation-First PRDs)
+For PRDs using the documentation-first approach:
+- **Read referenced documentation**: Check the "Content Location Map" in PRD to find where feature specs live
+- **Understand target state**: What functionality is documented but not yet implemented
+- **Check documentation completeness**: Are all user workflows and examples fully documented
+- **Validate cross-references**: Do all documentation links and references work correctly
+
+### Code Discovery
+- **Search for related files**: Use Grep/Glob to find files related to the feature
+- **Identify key modules**: Locate main implementation files mentioned in PRD
+- **Find test files**: Discover existing test coverage for the feature
+- **Check dependencies**: Review imports and module relationships
+
+### Implementation vs Documentation Gap Analysis
+- **Compare docs vs code**: What's documented vs actually implemented
+- **Partial implementations**: Identify half-finished features or TODO comments
+- **Documentation validation**: Can documented examples and commands actually work
+- **Architecture alignment**: Does current code match documented behavior and PRD architecture decisions
+- **Quality assessment**: Code style, error handling, test coverage gaps
+
+### Technical Feasibility Analysis
+- **Dependency conflicts**: Are PRD requirements compatible with existing code
+- **Breaking changes**: Will remaining tasks require refactoring existing code
+- **Integration points**: How new work connects with current implementation
+- **Technical debt**: Issues that might block or slow future work
+
+## Step 3: Completion Assessment (Only if Context Unclear)
+
+### Analyze Checkbox States
+Count and categorize all checkboxes:
+- **Completed**: `[x]` items
+- **Pending**: `[ ]` items  
+- **Deferred**: `[~]` items
+- **Blocked**: `[!]` items
+
+### Phase Analysis
+For each implementation phase:
+- Calculate completion percentage
+- Identify bottlenecks or stalled work
+- Assess readiness to move to next phase
+
+### Requirement Coverage
+Review requirement categories:
+- **Functional Requirements**: Core feature completion
+- **Non-Functional Requirements**: Quality and performance aspects
+- **Success Criteria**: Measurable outcomes
+- **Dependencies**: External requirements
+- **Risk Mitigation**: Risk management progress
+
+## Step 4: Dependency Analysis (Only if Context Unclear)
+
+### Identify Critical Path Items
+Look for items that:
+- **Block other work** - Must be completed before others can start
+- **Enable major capabilities** - Unlock significant value when completed
+- **Resolve current blockers** - Remove impediments to progress
+
+### Dependency Patterns
+
+#### PRD-Level Dependencies
+- **Sequential dependencies** - A must be done before B
+- **Parallel opportunities** - Multiple items that can be worked simultaneously  
+- **Foundation requirements** - Core capabilities needed by multiple features
+- **Integration points** - Items that connect different parts of the system
+
+#### Code-Level Dependencies  
+- **Import dependencies** - Modules that depend on others being implemented first
+- **Interface contracts** - APIs/types that must be defined before consumers
+- **Database schema** - Data model changes needed before business logic
+- **Test dependencies** - Tests that require certain infrastructure or mocks
+- **Build/deployment** - Configuration changes that affect multiple components
+
+## Step 5: Strategic Value Assessment (Only if Context Unclear)
+
+### High-Value Next Steps
+Prioritize items that:
+- **Unblock multiple other items** - High leverage impact
+- **Deliver user-visible value** - Direct user benefit
+- **Reduce technical risk** - Address major uncertainties
+- **Enable validation** - Allow testing of key assumptions
+- **Provide learning** - Generate insights for future work
+
+### Low-Priority Items
+Identify items that:
+- **Have many dependencies** - Can't be started yet
+- **Are nice-to-have** - Don't impact core value proposition
+- **Are optimization-focused** - Improve existing working features
+- **Require external dependencies** - Waiting on others
+
+## Step 6: Single Task Recommendation
+
+**Note**: If you arrived here from Step 0 (clear context), use the conversation history and known PRD state to make your recommendation. If you came through the full analysis, use your detailed findings.
+
+Present findings in this focused format:
+
+```markdown
+# Next Task Recommendation: [Feature Name]
+
+## Recommended Task: [Specific Task Name]
+
+**Why this task**: [2-3 sentences explaining why this is the highest priority right now]
+
+**What it unlocks**: [What becomes possible after completing this]
+
+**Dependencies**: [What's already complete that makes this ready to work on]
+
+**Effort estimate**: [Realistic time estimate]
+
+**Success criteria**: [How you'll know it's done]
+
+---
+
+**Do you want to work on this task?** 
+
+If yes, I'll help you design the implementation approach. If no, let me know what you'd prefer to work on instead.
+```
+
+## Step 7: Design Discussion (If Confirmed)
+
+If the user confirms they want to work on the recommended task, then dive into:
+
+### Implementation Planning
+- **Architecture approach**: How this fits into existing codebase
+- **Key components**: What needs to be built/modified
+- **Integration points**: How it connects with existing code
+- **Testing strategy**: How to validate the implementation
+
+### Design Decisions
+- **Technical choices**: Framework/library decisions to make
+- **Interface design**: APIs, data structures, user interfaces
+- **Error handling**: How to handle failure cases
+- **Performance considerations**: Scalability and optimization needs
+
+### Implementation Steps
+- **Step-by-step breakdown**: Logical sequence of implementation
+- **Quick wins**: Parts that can be completed first for validation
+- **Risk mitigation**: Addressing the biggest uncertainties first
+- **Testing checkpoints**: When and how to validate progress
+
+### Questions to Resolve
+- **Open decisions**: Design choices that need to be made
+- **Clarifications needed**: Requirements that need more detail
+- **Assumptions to validate**: Things we're assuming that should be confirmed
+
+## Success Criteria
+
+This command should:
+- ✅ Identify the single highest-value task to work on next based on current PRD state
+- ✅ Provide clear, compelling rationale for why this specific task should be prioritized
+- ✅ Wait for user confirmation before proceeding
+- ✅ If confirmed, provide detailed implementation design guidance
+- ✅ Keep teams focused on the most important work rather than overwhelming them with options
+- ✅ Enable immediate action by transitioning from recommendation to design discussion

package/shared-prompts/prd-start.md

@@ -0,0 +1,186 @@
+---
+name: prd-start
+description: Start working on a PRD implementation
+category: project-management
+---
+
+# PRD Start - Begin Implementation Work
+
+## Instructions
+
+You are helping initiate active implementation work on a specific Product Requirements Document (PRD). This command bridges the gap between PRD planning and actual development work by setting up the implementation context and providing clear next steps.
+
+## Process Overview
+
+1. **Auto-Detect Target PRD** - Intelligently determine which PRD to start implementing
+2. **Validate PRD Readiness** - Ensure the PRD is ready for implementation
+3. **Set Up Implementation Context** - Prepare the development environment
+4. **Identify Starting Point** - Determine the best first implementation task
+5. **Begin Implementation** - Launch into actual development work
+
+## Step 1: Smart PRD Detection
+
+**Auto-detect the target PRD using these context clues (in priority order):**
+
+1. **Git Branch Analysis** - Check current branch name for PRD patterns:
+   - `feature/prd-12-*` → PRD 12
+   - `prd-13-*` → PRD 13
+   - `feature/prd-*` → Extract PRD number
+
+2. **Recent Git Commits** - Look at recent commit messages for PRD references:
+   - "feat: PRD 12 setup" → PRD 12
+   - "docs: update prd-13 requirements" → PRD 13
+
+3. **Git Status Analysis** - Check modified/staged files for PRD clues:
+   - Modified `prds/12-*.md` → PRD 12
+   - Changes in PRD-specific directories
+
+4. **Available PRDs Discovery** - List all PRDs in `prds/` directory and identify those ready for implementation
+
+5. **Fallback to User Choice** - Only if context detection fails, ask user to specify
+
+**PRD Detection Implementation:**
+```bash
+# Use these tools to gather context:
+# 1. Check git branch: gitStatus shows current branch
+# 2. Check git status: Look for modified PRD files  
+# 3. List PRDs: Use LS or Glob to find prds/*.md files
+# 4. Recent commits: Use Bash 'git log --oneline -n 5' for recent context
+```
+
+**Detection Output:**
+```markdown
+🚀 **Starting work on PRD [X]** ([Feature Name])
+- Branch: `feature/prd-[X]-[feature-name]` ✅
+- PRD file: `prds/[X]-[feature-name].md` ✅
+- Current status: Ready for implementation ✅
+```
+
+## Step 2: PRD Readiness Validation
+
+Before starting implementation, validate that the PRD is ready:
+
+### Requirements Validation
+- **Functional Requirements**: Are core requirements clearly defined and complete?
+- **Success Criteria**: Are measurable success criteria established?
+- **Dependencies**: Are all external dependencies identified and available?
+- **Risk Assessment**: Have major risks been identified and mitigation plans created?
+
+### Documentation Analysis
+For documentation-first PRDs:
+- **Specification completeness**: Is the feature fully documented with user workflows?
+- **Integration points**: Are connections with existing features documented?
+- **API/Interface definitions**: Are all interfaces and data structures specified?
+- **Examples and usage**: Are concrete usage examples provided?
+
+### Implementation Readiness Checklist
+```markdown
+## PRD Readiness Check
+- [ ] All functional requirements defined ✅
+- [ ] Success criteria measurable ✅  
+- [ ] Dependencies available ✅
+- [ ] Documentation complete ✅
+- [ ] Integration points clear ✅
+- [ ] Implementation approach decided ✅
+```
+
+## Step 3: Implementation Context Setup
+
+### Git Branch Management
+**If not already on a feature branch:**
+```bash
+# Create feature branch for PRD implementation
+git checkout -b feature/prd-[issue-id]-[feature-name]
+git push -u origin feature/prd-[issue-id]-[feature-name]
+```
+
+### Development Environment Setup
+- **Dependencies**: Install any new dependencies required by the PRD
+- **Configuration**: Set up any configuration needed for development
+- **Test data**: Prepare test data or mock services
+- **Documentation tools**: Ensure documentation generation tools are available
+
+### Implementation Tracking Setup
+- **Mark PRD as "In Progress"**: Update PRD status section
+- **Create implementation log**: Add initial work log entry with start date
+- **Set up progress tracking**: Identify key milestones for progress updates
+
+## Step 4: Identify Implementation Starting Point
+
+### Critical Path Analysis
+Identify the highest-priority first task by analyzing:
+- **Foundation requirements**: Core capabilities that other features depend on
+- **Blocking dependencies**: Items that prevent other work from starting
+- **Quick wins**: Early deliverables that provide validation or value
+- **Risk mitigation**: High-uncertainty items that should be tackled early
+
+### Implementation Phases
+For complex PRDs, identify logical implementation phases:
+1. **Phase 1 - Foundation**: Core data structures, interfaces, basic functionality
+2. **Phase 2 - Integration**: Connect with existing systems, implement workflows
+3. **Phase 3 - Enhancement**: Advanced features, optimization, polish
+4. **Phase 4 - Validation**: Testing, documentation updates, deployment
+
+### First Task Recommendation
+Select the single best first task based on:
+- **Dependency analysis**: No blocking dependencies
+- **Value delivery**: Provides meaningful progress toward PRD goals
+- **Learning opportunity**: Generates insights for subsequent work
+- **Validation potential**: Allows early testing of key assumptions
+
+## Step 5: Begin Implementation
+
+### Implementation Kickoff
+Present the implementation plan:
+
+```markdown
+# 🚀 Starting Implementation: [PRD Name]
+
+## Selected First Task: [Task Name]
+
+**Why this task first**: [Clear rationale for why this is the optimal starting point]
+
+**What you'll build**: [Concrete description of what will be implemented]
+
+**Success criteria**: [How you'll know this task is complete]
+
+**Estimated effort**: [Time estimate]
+
+**Next steps after this**: [What becomes possible once this is done]
+
+## Implementation Approach
+[Brief technical approach and key decisions]
+
+## Ready to Start?
+Type 'yes' to begin implementation, or let me know if you'd prefer to start with a different task.
+```
+
+### Implementation Launch
+If confirmed, provide:
+- **Detailed task breakdown**: Step-by-step implementation guide
+- **Code structure recommendations**: Files to create/modify
+- **Testing approach**: How to validate the implementation
+- **Progress checkpoints**: When to update the PRD with progress
+
+### Progress Tracking Setup
+- **Update PRD status**: Mark relevant items as "in progress"
+- **Commit initial setup**: Make initial commit with branch and any setup changes
+- **Documentation updates**: Add PRD traceability comments to any docs being implemented
+
+## Success Criteria
+
+This command should:
+- ✅ Successfully identify the target PRD for implementation
+- ✅ Validate that the PRD is ready for development work
+- ✅ Set up proper implementation context (branch, environment, tracking)
+- ✅ Identify the optimal first implementation task
+- ✅ Provide clear, actionable next steps for beginning development
+- ✅ Bridge the gap between planning and actual coding work
+- ✅ Ensure proper progress tracking is established from the start
+
+## Notes
+
+- This command is designed for PRDs that are ready to move from planning to implementation
+- Use `prd-next` for ongoing implementation guidance on what to work on next
+- Use `prd-update-progress` to track implementation progress against PRD requirements
+- Use `prd-done` when PRD implementation is complete and ready for deployment/closure