When Stuck Problem Solving Dispatch

What Is When Stuck Problem Solving Dispatch?

When Stuck Problem Solving Dispatch is a structured technique designed to help software developers—and problem solvers in general—navigate the frustrating experience of being stuck. Rather than prescribing a one-size-fits-all solution, this skill provides a rapid “dispatch” mechanism: it analyzes the specific type of stuck-ness you’re experiencing and guides you toward the most suitable problem-solving approach.

This method is particularly useful when you’re unsure which technique to apply, and conventional debugging or brainstorming isn’t yielding results. Inspired by triage principles, When Stuck Problem Solving Dispatch asks targeted questions about your situation, matches your symptoms to common stuck-patterns, and recommends a relevant technique.

Whether you’re dealing with code complexity, innovation barriers, recurring patterns, unfounded assumptions, scalability questions, or bugs, this skill helps you apply the right tool at the right time.

Why Use When Stuck Problem Solving Dispatch?

Software development and technical problem solving often involve navigating ambiguous or complex challenges. The ways developers get stuck are varied: sometimes it’s a stubborn bug, sometimes it’s a convoluted design, and other times, it’s a block in creativity or a misleading assumption.

Jumping to a familiar technique—debugging, rewriting, or brainstorming—doesn’t always yield progress and can even waste time. When Stuck Problem Solving Dispatch addresses this by:

• Reducing context-switching costs: You avoid repeatedly trying ineffective strategies.
• Improving effectiveness: You’re directed to a proven technique tailored to your specific stuck-pattern.
• Building problem-solving skills: You develop awareness of different stuck-types and appropriate remedies.
• Saving time and frustration: You break inertia quickly and systematically. This approach is especially valuable for teams, code review sessions, and individual contributors aiming to work smarter, not harder.

How to Get Started

The skill is available as part of the claudekit-skills project. To use it in your workflow:

1. Recognize you’re stuck: Pause when you sense you’re spinning your wheels.
2. Answer the dispatch questions: The skill provides several diagnostic questions to identify your stuck-type.
3. Follow the recommended technique: Based on your answers, the skill points you to a targeted problem-solving method.
4. Apply, reflect, iterate: Use the suggested approach, then re-assess if you remain stuck. For example, if you’re facing code with endless if/else statements and growing special cases, the dispatch may point you toward “Simplification” or “Refactoring with Patterns.” If you’re unable to find any solution that fits, it may suggest “Collision Brainstorming” or “Lateral Thinking.” A sample dispatch flow might look like:

flowchart TD A[You're Stuck] --> B{What's the symptom?} B -->|Complexity/If-else/Special Cases| C[Apply Simplification (e.g., Strategy Pattern)] B -->|Need Breakthrough/No Fit| D[Use Lateral Thinking] B -->|Recurring Patterns| E[Search for Abstraction/Reusability] B -->|Assumptions Block| F[Test and Break Assumptions] B -->|Scalability Doubts| G[Prototype at Scale, Fuzz Testing] B -->|Bugs| H[Systematic Debugging]

Key Features - **Symptom-Based

Triage:** The core of this skill is its symptom-driven dispatch.

It asks concise, targeted questions like:

• “Are you repeating the same logic in multiple places?” - “Are all conventional approaches failing?” - “Is your solution built on an assumption that might not be true?” - Targeted Technique Recommendations: Each stuck-type is mapped to a set of proven methods. For instance:
• Complexity: Suggests refactoring, using design patterns, or simplifying logic.
• Innovation Blocks: Proposes collision brainstorming, lateral thinking, or consulting domain experts.
• Pattern Repetition: Encourages abstraction, DRY (Don’t Repeat Yourself) principle, or meta-programming.
• Assumptions: Guides you to explicitly list, test, and challenge your assumptions.
• Scale Concerns: Advises prototyping, stress testing, or simulating production scenarios.
• Bugs: Recommends systematic debugging, writing failing tests, or using print statements/logging.
• Quick Reference Flow: The dispatch diagram offers a visual, at-a-glance reference for choosing the next step.
• Lightweight Integration: Since the skill is documentation-driven, it’s easy to incorporate into team wikis, code review checklists, or personal workflows. Example: Refactoring Complexity Suppose you encounter this code:

def calculate_fee(user_type, amount): if user_type == 'student': return amount * 0.8 elif user_type == 'senior': return amount * 0.7 elif user_type == 'member': return amount * 0.9 # ...more cases... else: return amount

The dispatch would identify “growing special cases” and recommend refactoring, such as using a mapping:

FEE_DISCOUNTS = {'student': 0.8, 'senior': 0.7, 'member': 0.9} def calculate_fee(user_type, amount): return amount * FEE_DISCOUNTS.get(user_type, 1.0)

Best Practices - **Pause and

Diagnose:** Don’t rush into fixing; take a moment to answer the dispatch questions honestly.

• Be Specific: The more precisely you describe your “stuck” symptom, the better the recommendation.
• Iterate: If the first technique doesn’t work, re-examine your stuck-type. Sometimes problems overlap categories.
• Document and Share: When a dispatch technique helps, document it for team knowledge. Consider adding your own scenarios to the dispatch flow. -Reflect on Outcomes: After applying a recommended technique, take note of what worked and what didn’t. This reflection can help refine your future use of the dispatch and improve your overall problem-solving agility.

Important Notes

• Not a Silver Bullet: While the dispatch can rapidly guide you to effective techniques, some problems require deeper investigation or outside expertise. Use the dispatch as a starting point, not a final authority.
• Customize for Your Context: The provided flow and techniques are general. Adapt the dispatch questions and recommendations to fit your team’s domain, codebase, or workflow.
• Continuous Improvement: As you and your team encounter new stuck-patterns, update the dispatch flow. Treat it as a living document that evolves with your problem-solving experience.
• Psychological Blocks: Sometimes, being stuck is more about mindset than mechanics. If you notice recurring motivational or cognitive barriers, consider pairing the dispatch with techniques like rubber duck debugging, peer review, or even taking a break.

When Stuck Problem Solving Dispatch is a practical, adaptable tool for navigating the many ways technical work can grind to a halt. By diagnosing your stuck-type and applying targeted remedies, you can break through inertia and build a stronger, more resilient problem-solving practice.