--- name: dex-backlog description: AI-powered ranking of Dex system improvement ideas --- ## What This Command Does **In plain English:** AI-powered ranking of your Dex system improvement backlog based on current system state. Shows you what to build next. **When to use it:** - Weekly check-in on system improvements - After capturing several new ideas - When deciding what to work on next - During quarterly planning for system improvements **How to run it:** ``` /dex-backlog # Full review with re-ranking ``` --- ## Process Overview 1. **Load context** - Read system state, usage patterns, learnings 2. **Score ideas** - Calculate 5-dimension scores for each idea 3. **Re-rank backlog** - Sort by weighted total score 4. **Update file** - Write new rankings to `System/Dex_Ideas.md` 5. **Present top ideas** - Show top 5 with "Why now?" justification 6. **Offer next steps** - Workshop, implement, or defer --- ## Step 1: Load System Context Read these files to understand current system state: ### Required Files ``` System/Dex_Backlog.md # All ideas to score System/usage_log.md # Feature adoption patterns System/user-profile.yaml # Role, preferences CLAUDE.md # Current capabilities ``` ### Optional Files (if they exist) ``` System/Session_Learnings/ # Recent pain points (last 30 days) .claude/commands/ # Available commands core/mcp/ # MCP integrations 06-Resources/Learnings/ # Captured patterns ``` ### Extract Context Build a context dictionary with: - **Usage patterns**: Which features are used vs. unused - **Role profile**: PM, Sales, Leadership, Engineer, etc. - **Pain points**: Recent friction from session learnings - **System capabilities**: What's currently available - **Backlog state**: All ideas and their current scores --- ## Step 2: Score Each Idea For every active idea in the backlog, calculate 5 dimension scores. ### ⚠️ CURSOR FEASIBILITY CHECK (Do This First!) Before scoring ANY idea, validate it's actually implementable in Cursor: **What Cursor/Terminal CAN do:** - ✅ Read and write files - ✅ Execute shell commands - ✅ Build MCP tools for structured operations - ✅ Parse and transform file contents - ✅ Create caches and indexes (file-based) - ✅ Run commands on schedules or triggers **What Cursor/Terminal CANNOT do:** - ❌ Track user edits in real-time - ❌ Hook into Cursor internals - ❌ Monitor user actions passively - ❌ Access edit history without explicit file reads - ❌ Real-time background processes watching for changes **If idea requires something from the CANNOT list → Set all scores to 0 and flag as "Not feasible in Cursor"** --- After feasibility check passes, score on 5 dimensions: ### Dimension 1: Impact (35% weight) **Question:** How much would this improve daily workflow? **Scoring logic:** ``` Base score: 50 +20 if matches_recent_pain_points(): - Search System/Session_Learnings/ for mentions of this issue - Keywords from idea title/description appear in learnings - Problem stated explicitly in recent notes +15 if affects_daily_workflow(): - Touches commands used >3x per week (from usage_log) - Modifies core files (03-Tasks/Tasks.md, daily plans, person pages) - Impacts repetitive actions +15 if has_compound_value(): - Enables other ideas in backlog - Reduces technical debt - Creates reusable patterns - Unblocks multiple workflows Max: 100 ``` **Examples:** - "Auto-suggest person pages": 95 (daily workflow + enables relationship tracking) - "Export to blog": 40 (nice-to-have, doesn't affect core workflow) --- ### Dimension 2: Alignment (20% weight) **Question:** Does this fit actual usage patterns? **Scoring logic:** ``` Base score: 50 +30 based on usage_overlap(): - Extract features idea depends on - Check if those features are used (usage_log) - Calculate overlap: (used_features / total_features) * 30 +20 if fits_role_profile(): - PM roles: prioritize project/product features - Sales roles: prioritize relationship/account features - Leadership: prioritize synthesis/review features - Match category to role focus areas Max: 100 ``` **Examples:** - Idea needs "person pages" → Check if user has created person pages - If usage_log shows person pages = used → Higher alignment - If role = PM and idea = product features → +20 role fit --- ### Dimension 3: Token Efficiency (20% weight) **Question:** Does this reduce context/token usage? **CRITICAL - Cursor Feasibility Check:** Before scoring, verify the idea is implementable in Cursor/Terminal: - ✅ Can use: File read/write, MCP tools, command execution, file-based caching - ❌ Cannot use: Real-time edit tracking, Cursor internal hooks, monitoring user actions - If not feasible in Cursor → Score = 0 on all dimensions **Scoring logic:** ``` Base score: 50 +25 if reduces_token_usage(): - Caches/stores frequently accessed data (in files/MCP) - Compresses or summarizes verbose content (file-based) - Eliminates redundant reads - Enables more efficient retrieval patterns +15 if improves_context_efficiency(): - Reduces number of files that need reading - Creates structured summaries (YAML/JSON files) - Better indexing/search to avoid broad scans - Moves data from markdown to structured format +10 if enables_incremental_updates(): - Supports partial updates instead of full rewrites - Tracks changes in separate files - Lazy loading or on-demand computation Max: 100 ``` **Examples:** - "Cache meeting summaries in YAML": 90 (file-based, avoids re-reading) - "Track user edits for learning": 0 (NOT FEASIBLE - can't track edits) - "Add new field to template": 50 (neutral token impact) --- ### Dimension 4: Memory & Learning (15% weight) **Question:** Does this enhance system memory, persistence, or self-learning? **Scoring logic:** ``` Base score: 50 +20 if improves_memory_persistence(): - Stores learnings for future reference - Creates retrievable knowledge base - Captures patterns that compound over time - Builds historical context +20 if enables_self_learning(): - System learns from user behavior - Adapts recommendations based on patterns - Builds preference models - Improves predictions over time +10 if creates_feedback_loops(): - Tracks outcomes of suggestions - Measures effectiveness of recommendations - Refines based on what works Max: 100 ``` **Examples:** - "Learning pattern synthesizer": 95 (captures + compounds knowledge) - "Preference learning from edits": 85 (system adapts over time) - "Static template update": 50 (no learning component) --- ### Dimension 5: Proactivity (10% weight) **Question:** Does this enable proactive concierge behavior? **Scoring logic:** ``` Base score: 50 +25 if enables_anticipation(): - Surfaces relevant info before asked - Predicts needs based on patterns - Proactive suggestions not just reactive - Context-aware prompts +15 if automates_routine_decisions(): - Handles repetitive choices automatically - Learns user preferences and applies them - Reduces decision fatigue +10 if improves_timing(): - Right information at right time - Context-aware interruptions - Anticipates upcoming needs Max: 100 ``` **Examples:** - "Auto-prep meetings based on calendar": 90 (proactive + anticipatory) - "Suggest weekly priorities from patterns": 80 (learns and anticipates) - "Add manual review step": 50 (reactive, not proactive) --- ## Step 3: Calculate Weighted Score ``` total_score = ( (impact * 0.35) + (alignment * 0.20) + (token_efficiency * 0.20) + (memory_learning * 0.15) + (proactivity * 0.10) ) Round to integer: total_score = round(total_score) ``` **Priority Bands:** - **High Priority (85+):** Should tackle soon, high ROI - **Medium Priority (60-84):** Good ideas, right time matters - **Low Priority (<60):** Maybe later or needs refinement **Why These Dimensions:** - **Effort excluded:** With AI coding, implementation is cheap - focus on value, not cost - **Token efficiency prioritized:** Context efficiency is critical for performance - **Memory & learning emphasized:** System should get smarter over time - **Proactivity valued:** Concierge behavior > reactive tool --- ## Step 4: Update Backlog File Rewrite `System/Dex_Backlog.md` with: 1. **Update timestamp** at top 2. **Re-sort ideas** by total score (high to low) 3. **Update each idea** with new scores: ```markdown - **[idea-XXX]** Title - **Score:** 92 (Impact: 95, Alignment: 90, Effort: 85, Synergy: 95, Fresh: 70) - **Category:** category - **Captured:** YYYY-MM-DD - **Why ranked here:** [1-2 sentence reasoning based on scores] - **Description:** [original description] ``` 4. **Place in correct section** (High/Medium/Low priority) 5. **Preserve Archive section** (don't re-rank implemented ideas) --- ## Step 5: Present Results Show the user the top 5 ideas with context: ```markdown # 📊 Backlog Review Complete *Analyzed {{total_ideas}} ideas against current system state* ## 🔥 Top 5 Recommendations ### 1. [idea-XXX] {{title}} (Score: {{score}}) **Why now:** {{reasoning based on scores - be specific}} **Quick assessment:** - Impact: {{impact_justification}} - Fits your patterns: {{alignment_justification}} - Effort: {{effort_estimate}} **Next step:** Run `/dex-improve "{{title}}"` to workshop this idea --- ### 2. [idea-YYY] {{title}} (Score: {{score}}) [Same format] --- [... continue for top 5 ...] --- ## 📈 Backlog Health - **Total ideas:** {{total}} - **High priority (85+):** {{high_count}} - **Medium priority (60-84):** {{medium_count}} - **Low priority (<60):** {{low_count}} {{#if high_count > 5}} ⚠️ **Note:** You have {{high_count}} high-priority ideas. Consider tackling 1-2 this week to reduce backlog. {{/if}} {{#if low_count > 10}} 💡 **Tip:** {{low_count}} low-priority ideas might be worth archiving or refining. {{/if}} --- ## What would you like to do? 1. **Workshop an idea** → `/dex-improve "[title]"` 2. **Capture a new idea** → Use `capture_idea` MCP tool 3. **Mark one implemented** → Use `mark_implemented` MCP tool 4. **View full backlog** → Check `System/Dex_Backlog.md` ``` --- ## Step 6: Handle Special Cases ### If Backlog is Empty ```markdown # 📊 Backlog Review Your backlog is empty! Start capturing improvement ideas: - Use the `capture_idea` MCP tool anytime you think "I wish Dex did X" - Run `/dex-improve` to explore capability gaps - Run `/dex-level-up` to discover unused features The backlog system will help you track and prioritize ideas systematically. ``` ### If No High Priority Ideas ```markdown 🎉 **Good news:** No urgent improvements needed! Your system is working well. The backlog has ideas for later, but nothing critical right now. Consider: - Running `/dex-level-up` to discover unused features - Capturing ideas as they come up - Reviewing backlog quarterly ``` ### If Many Stale Ideas (>6 months old) ```markdown ⚠️ **Backlog maintenance needed** You have {{stale_count}} ideas older than 6 months. These might be: - No longer relevant → Archive them - Still valuable but not urgent → Keep them - Worth revisiting with new context → Re-evaluate descriptions Review stale ideas: {{list stale ideas}} Want to bulk archive these? I can help clean up the backlog. ``` --- ## Integration with Other Commands ### Hand-off to /dex-improve When user says "Let's work on #1" or "Workshop idea-XXX": 1. Read the idea details from backlog 2. Pass to `/dex-improve` with context: ``` /dex-improve "{{idea_title}}" Context from backlog: - Current score: {{score}} - Why it's prioritized: {{reasoning}} - Original description: {{description}} ``` 3. `/dex-improve` takes over for workshopping --- ## Scoring Implementation Tips ### Cursor Feasibility Check (Run FIRST) ```python def check_cursor_feasibility(idea: dict) -> dict: """ Returns: { 'feasible': bool, 'reason': str, 'capabilities_required': list } """ description_lower = idea['description'].lower() # Red flags - things Cursor CAN'T do cannot_do = { 'track edits': 'Cannot monitor file edits in real-time', 'watch user': 'Cannot observe user actions passively', 'hook into': 'Cannot hook into Cursor internals', 'monitor changes': 'Cannot monitor without explicit file reads', 'background process': 'No persistent background processes' } for phrase, reason in cannot_do.items(): if phrase in description_lower: return { 'feasible': False, 'reason': reason, 'suggestion': 'Reframe as file-based or command-triggered' } # Green flags - things Cursor CAN do can_do = ['file', 'read', 'write', 'mcp', 'command', 'cache', 'index', 'parse'] has_feasible_approach = any(word in description_lower for word in can_do) if has_feasible_approach: return {'feasible': True, 'reason': 'Uses Cursor-compatible operations'} else: return { 'feasible': False, 'reason': 'No clear implementation path in Cursor', 'suggestion': 'Add file-based or MCP approach' } ``` ### For Impact Calculation ```python def calculate_impact(idea, context): # First check feasibility feasibility = check_cursor_feasibility(idea) if not feasibility['feasible']: return 0 # Not feasible = 0 impact score = 50 # Check session learnings for pain point mentions learnings = context['session_learnings'] idea_keywords = extract_keywords(idea['title'] + idea['description']) for learning in learnings: learning_keywords = extract_keywords(learning['content']) if overlap(idea_keywords, learning_keywords) > 0.3: score += 20 break # Check if affects daily workflow if touches_daily_commands(idea, context['usage_log']): score += 15 # Check compound value if enables_other_ideas(idea, context['backlog']): score += 15 return min(score, 100) ``` ### For Alignment Calculation ```python def calculate_alignment(idea, context): score = 50 # Extract related features features = extract_related_features(idea) used_features = get_used_features(context['usage_log']) overlap_ratio = len(features & used_features) / len(features) score += int(overlap_ratio * 30) # Role fit role = context['user_profile']['role'] category = idea['category'] role_fit_map = { 'PM': ['projects', 'workflows', 'knowledge'], 'Sales': ['relationships', 'tasks'], 'Leadership': ['knowledge', 'workflows'] } if category in role_fit_map.get(role, []): score += 20 return min(score, 100) ``` ### For Token Efficiency Calculation ```python def calculate_token_efficiency(idea, context): score = 50 # Check if reduces token usage if reduces_reads(idea): # Caching, summaries score += 25 # Context efficiency improvements if improves_retrieval(idea): # Better indexing, structured data score += 15 # Incremental updates if supports_incremental(idea): # Partial updates, lazy loading score += 10 return min(score, 100) ``` ### For Memory & Learning Calculation ```python def calculate_memory_learning(idea, context): score = 50 # Memory persistence if stores_learnings(idea): # Knowledge base, historical context score += 20 # Self-learning capability if enables_adaptation(idea): # Learns from behavior, improves over time score += 20 # Feedback loops if tracks_outcomes(idea): # Measures effectiveness, refines score += 10 return min(score, 100) ``` ### For Proactivity Calculation ```python def calculate_proactivity(idea, context): score = 50 # Anticipation capability if enables_anticipation(idea): # Surfaces info before asked score += 25 # Automation of routine decisions if automates_decisions(idea): # Handles repetitive choices score += 15 # Timing improvements if improves_timing(idea): # Right info at right time score += 10 return min(score, 100) ``` --- ## Best Practices 1. **Run weekly** during `/week-plan` or standalone 2. **Don't obsess over scores** - they're guidance, not gospel 3. **Trust your instinct** - high score + gut feel = go 4. **Keep backlog lean** - max 20 active ideas 5. **Archive implemented** - celebrate progress 6. **Refine low scorers** - add detail to boost alignment/impact --- ## Philosophy The backlog isn't a todo list - it's a **decision support system**. Scores help you: - Surface high-value work - Avoid shiny object syndrome - Align improvements with actual usage - Make intentional choices But you're still the decision maker. If a low-scoring idea excites you, workshop it. The system serves you, not the other way around.