Problem-Solving Techniques
Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.
Best use case
Problem-Solving Techniques is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.
Teams using Problem-Solving Techniques should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/problem-solving/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How Problem-Solving Techniques Compares
| Feature / Agent | Problem-Solving Techniques | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Problem-Solving Techniques Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns. ## When to Use Apply when encountering: - **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching - **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking - **Recurring patterns** - Same issue across domains, reinventing solutions - **Assumption constraints** - Forced into "only way", can't question premise - **Scale uncertainty** - Production readiness unclear, edge cases unknown - **General stuck-ness** - Unsure which technique applies ## Quick Dispatch **Match symptom to technique:** | Stuck Symptom | Technique | Reference | |---------------|-----------|-----------| | Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` | | Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` | | Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` | | Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` | | Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` | | Unsure which technique to use | **When Stuck** | `references/when-stuck.md` | ## Core Techniques ### 1. Simplification Cascades Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z." **Key insight:** Everything is a special case of one general pattern. **Red flag:** "Just need to add one more case..." (repeating forever) ### 2. Collision-Zone Thinking Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?" **Key insight:** Revolutionary ideas from deliberate metaphor-mixing. **Red flag:** "I've tried everything in this domain" ### 3. Meta-Pattern Recognition Spot patterns appearing in 3+ domains to find universal principles. **Key insight:** Patterns in how patterns emerge reveal reusable abstractions. **Red flag:** "This problem is unique" (probably not) ### 4. Inversion Exercise Flip core assumptions to reveal hidden constraints. "What if the opposite were true?" **Key insight:** Valid inversions reveal context-dependence of "rules." **Red flag:** "There's only one way to do this" ### 5. Scale Game Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths. **Key insight:** What works at one scale fails at another. **Red flag:** "Should scale fine" (without testing) ## Application Process 1. **Identify stuck-type** - Match symptom to technique above 2. **Load detailed reference** - Read specific technique from `references/` 3. **Apply systematically** - Follow technique's process 4. **Document insights** - Record what worked/failed 5. **Combine if needed** - Some problems need multiple techniques ## Combining Techniques Powerful combinations: - **Simplification + Meta-pattern** - Find pattern, then simplify all instances - **Collision + Inversion** - Force metaphor, then invert its assumptions - **Scale + Simplification** - Extremes reveal what to eliminate - **Meta-pattern + Scale** - Universal patterns tested at extremes ## References Load detailed guides as needed: - `references/when-stuck.md` - Dispatch flowchart and decision tree - `references/simplification-cascades.md` - Cascade detection and extraction - `references/collision-zone-thinking.md` - Metaphor collision process - `references/meta-pattern-recognition.md` - Pattern abstraction techniques - `references/inversion-exercise.md` - Assumption flipping methodology - `references/scale-game.md` - Extreme testing procedures - `references/attribution.md` - Source and adaptation notes
Related Skills
web-frameworks
Build modern full-stack web applications with Next.js (App Router, Server Components, RSC, PPR, SSR, SSG, ISR), Turborepo (monorepo management, task pipelines, remote caching, parallel execution), and RemixIcon (3100+ SVG icons in outlined/filled styles). Use when creating React applications, implementing server-side rendering, setting up monorepos with multiple packages, optimizing build performance and caching strategies, adding icon libraries, managing shared dependencies, or working with TypeScript full-stack projects.
ui-ux-pro-max
UI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 8 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html, .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient.
ui-styling
Create beautiful, accessible user interfaces with shadcn/ui components (built on Radix UI + Tailwind), Tailwind CSS utility-first styling, and canvas-based visual designs. Use when building user interfaces, implementing design systems, creating responsive layouts, adding accessible components (dialogs, dropdowns, forms, tables), customizing themes and colors, implementing dark mode, generating visual designs and posters, or establishing consistent styling patterns across applications.
threejs
Build immersive 3D web experiences with Three.js - WebGL/WebGPU library for scenes, cameras, geometries, materials, lights, animations, loaders, post-processing, shaders (including node-based TSL), compute, physics, VR/XR, and advanced rendering. Use when creating 3D visualizations, games, interactive graphics, data viz, product configurators, architectural walkthroughs, or WebGL/WebGPU applications. Covers OrbitControls, GLTF/FBX loading, PBR materials, shadow mapping, post-processing effects (bloom, SSAO, SSR), custom shaders, instancing, LOD, animation systems, and WebXR.
template-skill
Replace with description of the skill and when Claude should use it.
skill-creator
Guide for creating effective skills, adding skill references, skill scripts or optimizing existing skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, frameworks, libraries or plugins usage, or API and tool integrations.
shopify
Build Shopify applications, extensions, and themes using GraphQL/REST APIs, Shopify CLI, Polaris UI components, and Liquid templating. Capabilities include app development with OAuth authentication, checkout UI extensions for customizing checkout flow, admin UI extensions for dashboard integration, POS extensions for retail, theme development with Liquid, webhook management, billing API integration, product/order/customer management. Use when building Shopify apps, implementing checkout customizations, creating admin interfaces, developing themes, integrating payment processing, managing store data via APIs, or extending Shopify functionality.
sequential-thinking
Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification. Use for complex problem decomposition, adaptive planning, analysis needing course correction, problems with unclear scope, multi-step solutions, and hypothesis-driven work.
research
Use when you need to research, analyze, and plan technical solutions that are scalable, secure, and maintainable.
repomix
Package entire code repositories into single AI-friendly files using Repomix. Capabilities include pack codebases with customizable include/exclude patterns, generate multiple output formats (XML, Markdown, plain text), preserve file structure and context, optimize for AI consumption with token counting, filter by file types and directories, add custom headers and summaries. Use when packaging codebases for AI analysis, creating repository snapshots for LLM context, analyzing third-party libraries, preparing for security audits, generating documentation context, or evaluating unfamiliar codebases.
planning
Use when you need to plan technical solutions that are scalable, secure, and maintainable.
payment-integration
Implement payment integrations with SePay (Vietnamese payment gateway with VietQR, bank transfers, cards) and Polar (global SaaS monetization platform with subscriptions, usage-based billing, automated benefits). Use when integrating payment processing, implementing checkout flows, managing subscriptions, handling webhooks, processing bank transfers, generating QR codes, automating benefit delivery, or building billing systems. Supports authentication (API keys, OAuth2), product management, customer portals, tax compliance (Polar as MoR), and comprehensive SDK integrations (Node.js, PHP, Python, Go, Laravel, Next.js).