Problem Solving
- 523 installs
- 2.2k repo stars
- Updated April 3, 2026
- mrgoonie/claudekit-skills
problem-solving is a Claude Code agent skill that applies systematic frameworks to break down ambiguous engineering problems and produce reliable solution paths for developers who need structured reasoning before writing
About
problem-solving is an agent skill from mrgoonie/claudekit-skills that structures how Claude tackles unclear technical problems through repeatable decomposition and solution-generation steps. Listed on skills.sh with 487 installs and rank 5 in its source repo, it is invoked when a task lacks a clear path, spans multiple components, or needs explicit trade-off analysis before implementation. The skill does not ship code generators or domain-specific APIs; instead it shapes agent behavior so debugging, architecture choices, and feature breakdowns follow a consistent method. Developers reach for problem-solving when they want Claude to slow down, enumerate constraints, compare options, and output an actionable plan rather than jumping straight to patches. It pairs well with implementation-focused skills because it front-loads clarity. Skip it when the task is a single-file fix with an obvious edit or when you already have a written spec to execute verbatim.
- Structured problem decomposition framework
- Root-cause analysis before solution generation
- Multiple solution path exploration with trade-off evaluation
- Verification and edge-case testing steps
- Works before any creative or implementation work
Problem Solving by the numbers
- 523 all-time installs (skills.sh)
- +5 installs in the week ending Jul 26, 2026 (Skillselion tracking)
- Ranked #739 of 3,280 Productivity & Planning skills by installs in the Skillselion catalog
- Data as of Aug 3, 2026 (Skillselion catalog sync)
npx skills add https://github.com/mrgoonie/claudekit-skills --skill problem-solvingAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 523 |
|---|---|
| repo stars | ★ 2.2k |
| Last updated | April 3, 2026 |
| Repository | mrgoonie/claudekit-skills ↗ |
How do you break down ambiguous coding problems systematically?
Get structured, systematic help breaking down ambiguous problems and generating reliable solutions with Claude.
Who is it for?
Developers facing unclear bugs, cross-cutting refactors, or multi-component features who want Claude to reason methodically before editing files.
Skip if: Developers with a finished spec or a one-line fix who only need direct code generation without planning overhead.
When should I use this skill?
The user describes a vague engineering problem, asks how to approach it, or needs a systematic plan before implementation.
What you get
Structured problem breakdown, constraint list, option comparison, and stepwise solution plan ready for implementation.
By the numbers
- 487 installs on skills.sh
- Rank 5 in mrgoonie/claudekit-skills on skills.sh
Files
Collision-Zone Thinking
Overview
Revolutionary insights come from forcing unrelated concepts to collide. Treat X like Y and see what emerges.
Core principle: Deliberate metaphor-mixing generates novel solutions.
Quick Reference
| Stuck On | Try Treating As | Might Discover |
|---|---|---|
| Code organization | DNA/genetics | Mutation testing, evolutionary algorithms |
| Service architecture | Lego bricks | Composable microservices, plug-and-play |
| Data management | Water flow | Streaming, data lakes, flow-based systems |
| Request handling | Postal mail | Message queues, async processing |
| Error handling | Circuit breakers | Fault isolation, graceful degradation |
Process
1. Pick two unrelated concepts from different domains 2. Force combination: "What if we treated [A] like [B]?" 3. Explore emergent properties: What new capabilities appear? 4. Test boundaries: Where does the metaphor break? 5. Extract insight: What did we learn?
Example Collision
Problem: Complex distributed system with cascading failures
Collision: "What if we treated services like electrical circuits?"
Emergent properties:
- Circuit breakers (disconnect on overload)
- Fuses (one-time failure protection)
- Ground faults (error isolation)
- Load balancing (current distribution)
Where it works: Preventing cascade failures Where it breaks: Circuits don't have retry logic Insight gained: Failure isolation patterns from electrical engineering
Red Flags You Need This
- "I've tried everything in this domain"
- Solutions feel incremental, not breakthrough
- Stuck in conventional thinking
- Need innovation, not optimization
Remember
- Wild combinations often yield best insights
- Test metaphor boundaries rigorously
- Document even failed collisions (they teach)
- Best source domains: physics, biology, economics, psychology
Problem-Solving Skills - Attribution
These skills were derived from agent patterns in the Amplifier project.
Source Repository:
- Name: Amplifier
- URL: https://github.com/microsoft/amplifier
- Commit: 2adb63f858e7d760e188197c8e8d4c1ef721e2a6
- Date: 2025-10-10
Skills Derived from Amplifier Agents
From insight-synthesizer agent:
- simplification-cascades - Finding insights that eliminate multiple components
- collision-zone-thinking - Forcing unrelated concepts together for breakthroughs
- meta-pattern-recognition - Spotting patterns across 3+ domains
- inversion-exercise - Flipping assumptions to reveal alternatives
- scale-game - Testing at extremes to expose fundamental truths
From ambiguity-guardian agent:
- (architecture) preserving-productive-tensions - Preserving multiple valid approaches
From knowledge-archaeologist agent:
- (research) tracing-knowledge-lineages - Understanding how ideas evolved
Dispatch pattern:
- when-stuck - Maps stuck-symptoms to appropriate technique
What Was Adapted
The amplifier agents are specialized long-lived agents with structured JSON output. These skills extract the core problem-solving techniques and adapt them as:
- Scannable quick-reference guides (~60 lines each)
- Symptom-based discovery via when_to_use
- Immediate application without special tooling
- Composable through dispatch pattern
Core Insight
Agent capabilities are domain-agnostic patterns. Whether packaged as "amplifier agent" or "superpowers skill", the underlying technique is the same. We extracted the techniques and made them portable.
Related skills
Grill MeHave an agent relentlessly pressure-test their plan or design until every decision branch is resolved and shared understanding is reached.691k196kGrill With DocsPressure-test architecture decisions against their live codebase and living documentation before writing production code.585k196k
Lark CalendarLet their coding agents read, create, and manage events inside Lark (Feishu) Calendar directly from natural language instructions.493kLark ImLet their coding agent send instant notifications, post updates, and receive commands directly inside Lark (Feishu) workspaces.493kLark ContactLet their AI coding agents read and write contacts, send messages, and manage user data inside Lark (Feishu).493kLark AttendanceAutomatically fetch and report daily attendance data from Lark (Feishu) into their own tools or agents.493kHow it compares
Choose problem-solving over implementation skills when the blocker is unclear scope or reasoning, not missing syntax or boilerplate.
FAQ
What does the problem-solving skill do in Claude Code?
The problem-solving skill from mrgoonie/claudekit-skills teaches Claude to decompose ambiguous engineering problems into constraints, options, and stepwise plans. It has 487 installs on skills.sh and is meant to run before large code edits.
When should developers use problem-solving instead of coding directly?
Developers should use problem-solving when a task spans multiple components, lacks a clear fix, or needs explicit trade-off analysis. The skill outputs structured plans; skip it for obvious single-file patches.