| name | priority-assessment |
| description | Guide for calculating and explaining task priority scores |
Priority Assessment Skill
This skill helps calculate meaningful priority scores for tasks based on multiple factors.
Priority Score Formula
Priority scores range from 0-100 and are calculated from five factors:
Priority Score = Dependency (30) + Critical Path (25) + Business Value (20) + Complexity (15) + User Hints (10)
Factor Breakdown
1. Dependency Factor (Max 30 points)
How many other tasks does this task block?
| Blocks | Score | Reasoning |
|---|
| 0 tasks | 0 | No other tasks waiting on this |
| 1 task | 10 | Minor blocker |
| 2 tasks | 18 | Moderate blocker |
| 3 tasks | 24 | Significant blocker |
| 4+ tasks | 30 | Critical path item |
Example: "Create auth context" blocks login, logout, protected routes, and session persistence = 30 points
2. Critical Path Factor (Max 25 points)
Is this task on the longest path to completion?
| Position | Score | Reasoning |
|---|
| Not on critical path | 0 | Can be done in parallel |
| On critical path, short | 10 | Part of main sequence |
| On critical path, medium | 18 | Important stepping stone |
| On critical path, start | 25 | Must be done first |
Example: "Define database schema" at the start of data layer critical path = 25 points
3. Business Value Factor (Max 20 points)
How much value does this deliver to users/stakeholders?
| Value | Score | Indicators |
|---|
| Low | 0-5 | Technical debt, internal only |
| Medium | 6-12 | Incremental improvement |
| High | 13-17 | Core functionality |
| Critical | 18-20 | User-facing, revenue-impacting |
Keywords that suggest high value:
- "user", "customer", "revenue"
- "security", "performance"
- "core", "essential", "required"
- "blocking", "urgent"
Example: "Add payment processing" = 20 points (revenue-critical)
4. Complexity Factor (Max 15 points)
Simpler tasks should be done first (higher priority) when other factors are equal.
| Complexity | Score | Characteristics |
|---|
| Trivial | 15 | <30 min, config change |
| Simple | 12 | 1-2 hours, single file |
| Moderate | 8 | 2-4 hours, multiple files |
| Complex | 4 | 4+ hours, architecture |
| Very Complex | 0 | Multi-day, high risk |
Reasoning: Quick wins build momentum and reduce backlog.
Example: "Fix typo in error message" = 15 points (trivial fix)
5. User Hint Factor (Max 10 points)
Did the user express urgency or importance?
| Signal | Score |
|---|
| Explicit "urgent", "ASAP", "critical" | 10 |
| "Important", "need this soon" | 7 |
| "Nice to have", "eventually" | 2 |
| No signal | 5 (neutral) |
Example: "We need this for the demo next week" = 10 points
Priority Levels
Map scores to priority levels:
| Score Range | Level | Action |
|---|
| 85-100 | Critical | Do immediately |
| 65-84 | High | Do soon |
| 40-64 | Medium | Normal queue |
| 20-39 | Low | When time permits |
| 0-19 | Trivial | Backlog |
Example Assessment
Task: "Create user authentication context"
Factor Analysis:
- Dependency (30): Blocks 4 tasks (login, logout, protected routes, session) = 30/30
- Critical Path (25): First item in auth chain = 25/25
- Business Value (20): Enables all user features = 18/20
- Complexity (15): Moderate (2-3 hours, state management) = 8/15
- User Hints (10): User said "auth is a prerequisite" = 7/10
Total: 30 + 25 + 18 + 8 + 7 = 88/100 (Critical)
Reason: "Critical blocker for authentication chain. Must be completed first to unblock login, logout, and protected routes. Moderate complexity but high value - enables all user-specific features."
Priority Explanation Template
When explaining priority to users:
[Task Title] - Score: [X]/100 ([Level])
This task scores [high/medium/low] because:
- [Key factor 1]: [explanation]
- [Key factor 2]: [explanation]
[If blocking]: This must be done before [dependent tasks].
[If blocked]: This depends on [blocker tasks] being completed first.
Common Priority Patterns
Foundation First
Infrastructure and types typically score high due to dependency factor:
- Database schemas
- Type definitions
- API contracts
- Shared utilities
User Value Wins
When dependencies are equal, prioritize user-facing work:
- Visible features over internal refactoring
- Bug fixes over new features
- Performance improvements users notice
Quick Wins Matter
Simple, high-value tasks should be prioritized:
- Easy bug fixes
- Configuration changes
- Copy updates
- Small UX improvements
Anti-Patterns
Don't:
- Prioritize based only on user excitement
- Ignore technical dependencies
- Let all tasks become "high priority"
- Forget to reassess after scope changes
Do:
- Consider the full picture
- Update priorities when dependencies change
- Communicate trade-offs clearly
- Revisit priorities as context evolves