Which Skill Should I Use?

Quick decision guide for choosing the right tool.

Quick Decision Tree

START: What do you need to do?
  │
  ├─► Debug/test failure?
  │   └─► Use: systematic-debugging
  │       └─► 3+ failed attempts?
  │           └─► Add: troubleshoot-and-continue
  │
  ├─► Complete work session?
  │   └─► Check time gate: finish-work
  │       └─► Time remaining?
  │           ├─► YES: Keep working
  │           └─► NO: verification-before-completion
  │               └─► /finish (handoff docs)
  │                   └─► finishing-a-development-branch (git)
  │
  ├─► Execute implementation plan?
  │   ├─► Have plan already?
  │   │   ├─► Stay in this session?
  │   │   │   ├─► YES: subagent-driven-development
  │   │   │   └─► NO: executing-plans
  │   │   └─► Need fresh subagent per task + 2 reviewers?
  │   │       └─► Use: subagent-driven-development
  │   └─► Need to create plan first?
  │       └─► Use: writing-plans
  │
  ├─► Complex multi-step work (30+ min)?
  │   ├─► Batch asset generation (10+ sprites/tiles)?
  │   │   └─► Use: /ralph
  │   └─► Feature implementation?
  │       └─► Use: /longplan
  │
  ├─► Parallel investigation?
  │   ├─► Multiple independent problems?
  │   │   └─► Use: dispatching-parallel-agents
  │   └─► Research/analysis tasks?
  │       └─► Use: longplan (5-10+ parallel subagents)
  │
  ├─► Stuck/blocked?
  │   └─► Use: troubleshoot-and-continue
  │       └─► Exhausted all resources?
  │           └─► Consider asking user (last resort)
  │
  └─► Review code?
      ├─► Request review of your work?
      │   └─► Use: requesting-code-review
      └─► Review someone else's PR?
          └─► Use: receiving-code-review

Detailed Selection Guide

Execution Skills (Getting Work Done)

Debugging Skills (Fixing Problems)

Completion Skills (Finishing Work)

Planning Skills (Before Execution)

Common Confusions Clarified

/longplan vs /ralph

• /longplan: Complex features, dialogue writing, multi-file changes
• /ralph: Batch asset generation (sprites, tiles, images)
• Overlap: Both use parallel subagents, but /ralph is optimized for asset generation

subagent-driven-development vs executing-plans

• subagent-driven-development: Same session, fresh subagent per task + 2 reviewers
• executing-plans: New parallel session (separate window)
• Key difference: Session context (same vs parallel)

systematic-debugging vs troubleshoot-and-continue

• systematic-debugging: Scientific debugging methodology (4 phases)
• troubleshoot-and-continue: Resource exhaustion for autonomous work
• Use together: After 3 failed attempts in systematic debugging, activate troubleshoot-and-continue

finish-work vs /finish

• finish-work: Time gate (session-level)
• /finish: Handoff docs (after work complete)
• Use in sequence: finish-work FIRST, then /finish

Autonomous Work Recommendations

For long autonomous blocks (2+ hours):

1. Start with: /longplan (creates structured plan)
2. Debugging: systematic-debugging + troubleshoot-and-continue
3. Self-checkpoint: Every 30 min or 5 file operations
4. Quality gates: verification-before-completion
5. End with: finish-work → /finish

For batch tasks (10+ similar items):

1. Use: /ralph (optimized for batch work)
2. Self-checkpoint: Progress file auto-updates
3. End with: finish-work → /finish

For stuck tasks:

1. First: Try 2-3 alternatives yourself
2. Then: troubleshoot-and-continue protocol
3. Spawn: MiniMax subagents for help
4. Last resort: Document and skip to next task

When Skills Combine

Example: Complex feature with debugging

1. /longplan (create plan)
2. During 2A: systematic-debugging (if bugs found)
3. If stuck: troubleshoot-and-continue
4. End: finish-work → /finish
5. If branch: finishing-a-development-branch

Example: Batch asset generation with issues

1. /ralph (generate assets)
2. If failures: dispatching-parallel-agents (parallel debugging)
3. End: finish-work → /finish

Quick Reference Card

Remember: When in doubt, start with the most specific skill for your task. Skills can be combined sequentially.