SkillAgentSearch skills...

ensemble-solving

Generate multiple diverse solutions in parallel and select the best. Use for architecture decisions, code generation with multiple valid approaches, or creative tasks where exploring alternatives improves quality.

Install / Use

npx skills add mhattingpete/claude-skills-marketplace --skill ensemble-solving

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

81/100

Supported Platforms

Universal

Tags

Our assessment of ensemble-solving

ensemble-solving scores 81/100 on our quality scale, 3536th of 4,702 Development & Engineering skills we index.

Its SKILL.md is 4.9 KB long, well organised into 16 sections with 2 code examples: a solid amount of guidance for an agent.

It has 678 GitHub stars, a meaningful sign that others use it.

Substance
26/30
Structure
18/20
Description
15/15
Adoption
12/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-11-08 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

ensemble-solving compared with similar skills

All 4 of these similar skills score higher than ensemble-solving; compare them before choosing.

SkillScoreStarsUpdatedFormat
ensemble-solving (this skill)by mhattingpete816784mo agoSKILL.md
taste-skillby Leonxlnx100117.6k9d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.3ktodayCLAUDE.md
claude-howtoby luongnv8910047.4k3d agoCLAUDE.md
lobehubby lobehub10085.7ktodayMCP Server

Frequently asked questions

How do I install ensemble-solving?
Run npx skills add mhattingpete/claude-skills-marketplace --skill ensemble-solving. The install tabs above show the steps for each supported agent.
Which AI agents does ensemble-solving work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is ensemble-solving safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is ensemble-solving still maintained?
The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: ensemble-solving description: Generate multiple diverse solutions in parallel and select the best. Use for architecture decisions, code generation with multiple valid approaches, or creative tasks where exploring alternatives improves quality.

Ensemble Problem Solving

Generate multiple solutions in parallel by spawning 3 subagents with different approaches, then evaluate and select the best result.

When to Use

Activation phrases:

  • "Give me options for..."
  • "What's the best way to..."
  • "Explore different approaches..."
  • "I want to see alternatives..."
  • "Compare approaches for..."
  • "Which approach should I use..."

Good candidates:

  • Architecture decisions with trade-offs
  • Code generation with multiple valid implementations
  • API design with different philosophies
  • Naming, branding, documentation style
  • Refactoring strategies
  • Algorithm selection

Skip ensemble for:

  • Simple lookups or syntax questions
  • Single-cause bug fixes
  • File operations, git commands
  • Deterministic configuration changes
  • Tasks with one obvious solution

What It Does

  1. Analyzes the task to determine if ensemble approach is valuable
  2. Generates 3 distinct prompts using appropriate diversification strategy
  3. Spawns 3 parallel subagents to develop solutions independently
  4. Evaluates all solutions using weighted criteria
  5. Returns the best solution with explanation and alternatives summary

Approach

Step 1: Classify Task Type

Determine which category fits:

  • Code Generation: Functions, classes, APIs, algorithms
  • Architecture/Design: System design, data models, patterns
  • Creative: Writing, naming, documentation

Step 2: Invoke Ensemble Orchestrator

Task tool with:
- subagent_type: 'ensemble-orchestrator'
- description: 'Generate and evaluate 3 parallel solutions'
- prompt: [User's original task with full context]

The orchestrator handles:

  • Prompt diversification
  • Parallel execution
  • Solution evaluation
  • Winner selection

Step 3: Present Result

The orchestrator returns:

  • The winning solution (in full)
  • Evaluation scores for all 3 approaches
  • Why the winner was selected
  • When alternatives might be preferred

Diversification Strategies

For Code (Constraint Variation): | Approach | Focus | |----------|-------| | Simplicity | Minimal code, maximum readability | | Performance | Efficient, optimized | | Extensibility | Clean abstractions, easy to extend |

For Architecture (Approach Variation): | Approach | Focus | |----------|-------| | Top-down | Requirements → Interfaces → Implementation | | Bottom-up | Primitives → Composition → Structure | | Lateral | Analogies from other domains |

For Creative (Persona Variation): | Approach | Focus | |----------|-------| | Expert | Technical precision, authoritative | | Pragmatic | Ship-focused, practical | | Innovative | Creative, unconventional |

Evaluation Rubric

| Criterion | Base Weight | Description | |-----------|-------------|-------------| | Correctness | 30% | Solves the problem correctly | | Completeness | 20% | Addresses all requirements | | Quality | 20% | How well-crafted | | Clarity | 15% | How understandable | | Elegance | 15% | How simple/beautiful |

Weights adjust based on task type.

Example

User: "What's the best way to implement a rate limiter?"

Skill:

  1. Classifies as Code Generation
  2. Invokes ensemble-orchestrator
  3. Three approaches generated:
    • Simple: Token bucket with in-memory counter
    • Performance: Sliding window with atomic operations
    • Extensible: Strategy pattern with pluggable backends
  4. Evaluation selects extensible approach (score 8.4)
  5. Returns full implementation with explanation

Output:

## Selected Solution

[Full rate limiter implementation with strategy pattern]

## Why This Solution Won

The extensible approach scored highest (8.4) because it provides
a clean abstraction that works for both simple use cases and
complex distributed scenarios. The strategy pattern allows
swapping Redis/Memcached backends without code changes.

## Alternatives

- **Simple approach**: Best if you just need basic in-memory
  limiting and will never scale beyond one process.

- **Performance approach**: Best for high-throughput scenarios
  where every microsecond matters.

Success Criteria

  • 3 genuinely different solutions generated
  • Clear evaluation rationale provided
  • Winner selected with confidence
  • Alternatives summarized with use cases
  • User understands trade-offs

Token Cost

~4x overhead vs single attempt. Worth it for:

  • High-stakes architecture decisions
  • Creative work where first attempt rarely optimal
  • Learning scenarios where seeing alternatives is valuable
  • Code that will be maintained long-term

Integration

  • feature-planning: Can ensemble architecture decisions
  • code-auditor: Can ensemble analysis perspectives
  • plan-implementer: Executes the winning approach

Related Skills

View on GitHub
GitHub Stars678
CategoryDevelopment
Updated3mo ago
Forks96

Languages

HTML

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info