home / skills / nickcrew / claude-cortex / assumption_buster

assumption_buster skill

/skills/collaboration/assumption_buster

This skill helps you bust assumptions to unlock new solution angles by transforming beliefs and generating reframed ideas with quick tests.

npx playbooks add skill nickcrew/claude-cortex --skill assumption_buster

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
999 B
---
name: assumption-buster
description: Flip, remove, or exaggerate assumptions to unlock new solution angles.
license: MIT
---

# `/collaboration:assumption-buster`

Use when the team feels boxed in or every idea sounds the same.

## Inputs
- Topic or problem statement
- Known assumptions/constraints (even if informal)
- Optional mode flag: `--opposite`, `--zero`, or `--10x`

## Steps
1. List core assumptions (facts, beliefs, constraints).
2. Transform each via chosen operator (opposite/zero/10x).
3. Generate 1–2 reframed ideas per transformed assumption.
4. Capture evidence to collect and a fast test for each idea.
5. Pick the most promising 2–3 and move to `/ctx:plan` or Tasks.

## Output Template
```
### Assumptions
### Transforms (opposite/zero/10x)
### Reframed Ideas
- Idea … (evidence, fast test)
### Top Picks
```

## Pairings
- Run before `/collaboration:idea-lab` if you need to loosen constraints.
- Feed winners into `/collaboration:concept-forge` to score/prioritize.

Overview

This skill flips, removes, or magnifies assumptions to reveal new solution angles when a team feels stuck or ideas converge. It applies three simple operators—opposite, zero, and 10x—to systematically reframe constraints and generate practical, testable concepts. Use it to break mental ruts and produce a short list of candidate directions to prototype or prioritize.

How this skill works

You provide a topic and any known assumptions or constraints, then choose a transform mode: opposite (invert an assumption), zero (remove it), or 10x (exaggerate it). The skill lists core assumptions, applies the chosen operator to each, generates 1–2 reframed ideas for every transform, and proposes quick evidence to collect and a fast test for each idea. It ends with 2–3 top picks ready to move into planning or task workflows.

When to use it

  • When brainstorming yields similar or incremental ideas and you need fresh directions
  • When constraints feel implicit or unchallenged and you want to surface hidden opportunities
  • Before prioritization to broaden options for scoring and comparison
  • When preparing rapid experiments and you need testable hypotheses
  • To unblock teams that report being "boxed in" by beliefs or past solutions

Best practices

  • Capture assumptions explicitly, including soft beliefs and habits, not just formal constraints
  • Pick one transform mode per run to keep outputs coherent and actionable
  • Create a single-sentence fast test for each idea to enable quick validation
  • Limit reframed ideas to 1–2 per transform to avoid analysis paralysis
  • Feed top picks into planning or prioritization flows immediately to maintain momentum

Example use cases

  • Product team stuck on onboarding ideas: invert the assumption that users must register first and test guest-first flows
  • Service design for retail: zero out the assumption that staff must be present and explore self-service or remote-assist options
  • Growth experiments: 10x the referral incentive to see if virality mechanics emerge and design a short A/B test
  • Platform roadmap: flip the assumption that features must be backwards compatible to find bolder architectural options
  • Operations improvement: remove the constraint of fixed hours and prototype asynchronous handoff patterns

FAQ

Which transform should I pick first?

Start with whichever yields the biggest mindset shift for your context—use opposite to reveal counterintuitive ideas, zero to free constraints, or 10x to stress-test scale assumptions.

How many assumptions should I list?

Aim for 5–12 core assumptions. Enough to cover the problem without generating too many reframes to evaluate.