agentleFS
vfarcicvfarcic/dot-ai/.claude/skills/dot-ai-prd-next/SKILL.md

dot-ai-prd-next

Skill336 starsChanged 10 months agoMITView on GitHub

Analyze existing PRD to identify and recommend the single highest-priority task to work on next

The file

Show its rules and text

We split this skill into the rules it gives an agent

20 rules. About 0 are common, 19 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈19

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Auto-Detect Target PRD: - If context unclear, intelligently determine which PRD to analyze

    line 16
  2. Distinctive:

    Design Discussion: - If confirmed, dive into implementation design details

    line 20
  3. Distinctive:

    Use conversation history to understand current state and recent progress

    line 36
  4. Distinctive:

    Git Branch Analysis: - Check current branch name for PRD patterns:

    line 46
  5. Distinctive:

    Recent Git Commits: - Look at recent commit messages for PRD references:

    line 51
  6. Distinctive:

    Git Status Analysis: - Check modified/staged files for PRD clues:

    line 55
  7. Distinctive:

    Fallback to User Choice: - Only if context detection fails, ask user to specify

    line 63
  8. Very specific:

    Read the PRD file from prds/[issue-id]-[feature-name].md

    line 89
  9. Distinctive:

    Before assessing task priorities, analyze both the documented specifications and current implementation state:

    line 95
  10. Distinctive:

    Read referenced documentation: Check the "Content Location Map" in PRD to find where feature specs live

    line 99
  11. Distinctive:

    Validate cross-references: Do all documentation links and references work correctly

    line 102
  12. Distinctive:

    Search for related files: Use Grep/Glob to find files related to the feature

    line 105
  13. Distinctive:

    Look for items that:

    line 149
  14. Distinctive:

    Block other work: - Must be completed before others can start

    line 150
  15. Distinctive:

    Resolve current blockers: - Remove impediments to progress

    line 152
  16. Distinctive:

    Are nice-to-have: - Don't impact core value proposition

    line 182
  17. Distinctive:

    Note: If you arrived here from Step 0 (clear context), use the conversation history and known PRD state to make your recommendation.

    line 188
  18. Distinctive:

    If the user confirms they want to work on the recommended task, then dive into:

    line 214
  19. Distinctive:

    Testing checkpoints: When and how to validate progress

    line 232
  20. Distinctive:

    After the user completes the task implementation, output ONLY this message:

    line 253

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

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

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
  7. Implementation - User implements the task
  8. Update Progress - Prompt user to run /prd-update-progress

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:

# 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:

🎯 **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:

# 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]

**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

Step 8: Update Progress After Completion

CRITICAL: Do NOT update the PRD yourself. Do NOT edit PRD files directly. Your job is to prompt the user to run the update command.

After the user completes the task implementation, output ONLY this message:


Task implementation complete.

To update PRD progress and commit your work, run /prd-update-progress.


Then STOP. Do not proceed further. The /prd-update-progress command handles PRD updates, progress tracking, and commits. This separation ensures proper workflow and avoids duplicate/conflicting updates.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.