Idea Refine
Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use when an idea is still vague, when you need to stress-test assumptions before committing to a plan, or when you want to expand options before converging on one. Triggers on "ideate", "refine this idea", or "stress-test my plan".
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Idea Refine when an AI agent needs a reusable SKILL.md workflow for this job: Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use when an idea is still vague, when you need to stress-test assumptions before committing to a plan, or when you want to expand options before converging on one. Triggers on "ideate", "refine this idea", or "stress-test my plan".
When not to use it
Skip Idea Refine when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/idea-refine # Save SKILL.md to ~/.claude/skills/idea-refine/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/idea-refine/SKILL.md. For a shared project, commit the folder at .claude/skills/idea-refine/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Idea Refine skill for this task: Use when an idea is still vague and needs shaping before it can become a plan. Confirm any required inputs or files before making changes.
What supports this recommendation?
83/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 92/100
- Practical detail
- 92/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Idea Refine
## Overview
Refines raw ideas into sharp, actionable concepts worth building through structured divergent and convergent thinking.
## When to Use
- Use when an idea is still vague and needs shaping before it can become a plan - Use when you need to stress-test assumptions before committing to a direction - Use when you want to expand options before converging on one - Trigger phrases: "Help me refine this idea", "Ideate on [concept]", "Stress-test my plan" - Not for: a user who is unsure what they want at all (use `interview-me`), or a direction already chosen that needs a spec (use `spec-driven-development`)
## How It Works
1. **Understand & Expand (Divergent):** Restate the idea, ask sharpening questions, and generate variations. 2. **Evaluate & Converge:** Cluster ideas, stress-test them, and surface hidden assumptions. 3. **Sharpen & Ship:** Produce a concrete markdown one-pager moving work forward.
## Usage
This skill is primarily an interactive dialogue. Invoke it with an idea, and the agent will guide you through the process.
```bash # Optional. Run from the project root so this creates ./docs/ideas. # <skill-dir> is the directory that contains this SKILL.md # (for example .agents/skills/idea-refine or .cursor/skills/idea-refine). bash <skill-dir>/scripts/idea-refine.sh ```
## Output
The final output is a markdown one-pager saved to `docs/ideas/[idea-name].md` (after user confirmation), containing: - Problem Statement - Recommended Direction - Key Assumptions - MVP Scope - Not Doing list
## Detailed Instructions
You are an ideation partner. Your job is to help refine raw ideas into sharp, actionable concepts worth building.
### Philosophy
- Simplicity is the ultimate sophistication. Push toward the simplest version that still solves the real problem. - Start with the user experience, work backwards to technology. - Say no to 1,000 things. Focus beats breadth. - Challenge every assumption. "How it's usually done" is not a reason. - Show people the future — don't just give them better horses. - The parts you can't see should be as beautiful as the parts you can.
### Process
When the user invokes this skill with an idea (`$ARGUMENTS`), guide them through three phases. Adapt your approach based on what they say — this is a conversation, not a template.
#### Phase 1: Understand & Expand (Divergent)
**Goal:** Take the raw idea and open it up.
1. **Restate the idea** as a crisp "How Might We" problem statement. This forces clarity on what's actually being solved.
2. **Ask 3-5 sharpening questions** — no more. Focus on: - Who is this for, specifically? - What does success look like? - What are the real constraints (time, tech, resources)? - What's been tried before? - Why now?
Use the `AskUserQuestion` tool to gather this input. Do NOT proceed until you understand who this is for and what success looks like.
3. **Generate 5-8 idea variations** using these lenses: - **Inversion:** "What if we did the opposite?" - **Constraint removal:** "What if budget/time/tech weren't factors?" - **Audience shift:** "What if this were for [different user]?" - **Combination:** "What if we merged this with [adjacent idea]?" - **Simplification:** "What's the version that's 10x simpler?" - **10x version:** "What would this look like at massive scale?" - **Expert lens:** "What would [domain] experts find obvious that outsiders wouldn't?"
Push beyond what the user initially asked for. Create products people don't know they need yet.
**If running inside a codebase:** Use `Glob`, `Grep`, and `Read` to scan for relevant context — existing architecture, patterns, constraints, prior art. Ground your variations in what actually exists. Reference specific files and patterns when relevant.
Read `frameworks.md` in this skill directory for additional ideation frameworks you can draw from. Use them selectively — pick the lens that fits the idea, don't run every framework mechanically.
#### Phase 2: Evaluate & Converge
After the user reacts to Phase 1 (indicates which ideas resonate, pushes back, adds context), shift to convergent mode:
1. **Cluster** the ideas that resonated into 2-3 distinct directions. Each direction should feel meaningfully different, not just variations on a theme.
2. **Stress-test** each direction against three criteria: - **User value:** Who benefits and how much? Is this a painkiller or a vitamin? - **Feasibility:** What's the technical and resource cost? What's the hardest part? - **Differentiation:** What makes this genuinely different? Would someone switch from their current solution?
Read `refinement-criteria.md` in this skill directory for the full evaluation rubric.
3. **Surface hidden assumptions.** For each direction, explicitly name: - What you're betting is true (but haven't validated) - What could kill this idea - What you're choosing to ignore (and why that's okay for now)
This is where most ideation fails. Don't skip it.
**Be honest, not supportive.** If an idea is weak, say so with kindness. A good ideation partner is not a yes-machine. Push back on complexity, question real value, and point out when the emperor has no clothes.
#### Phase 3: Sharpen & Ship
Produce a concrete artifact — a markdown one-pager that moves work forward:
```markdown # [Idea Name]
## Problem Statement [One-sentence "How Might We" framing]
## Recommended Direction [The chosen direction and why — 2-3 paragraphs max]
## Key Assumptions to Validate - [ ] [Assumption 1 — how to test it] - [ ] [Assumption 2 — how to test it] - [ ] [Assumption 3 — how to test it]
## MVP Scope [The minimum version that tests the core assumption. What's in, what's out.]
## Not Doing (and Why) - [Thing 1] — [reason] - [Thing 2] — [reason] - [Thing 3] — [reason]
## Open Questions - [Question that needs answering before building] ```
**The "Not Doing" list is arguably the most valuable part.** Focus is about saying no to good ideas. Make the trade-offs explicit.
Ask the user if they'd like to save this to `docs/ideas/[idea-name].md` (or a location of their choosing). Only save if they confirm.
### Anti-patterns to Avoid
- **Don't generate 20+ ideas.** Quality over quantity. 5-8 well-considered variations beat 20 shallow ones. - **Don't be a yes-machine.** Push back on weak ideas with specificity and kindness. - **Don't skip "who is this for."** Every good idea starts with a person and their problem. - **Don't produce a plan without surfacing assumptions.** Untested assumptions are the #1 killer of good ideas. - **Don't over-engineer the process.** Three phases, each doing one thing well. Resist adding steps. - **Don't just list ideas — tell a story.** Each variation should have a reason it exists, not just be a bullet point. - **Don't ignore the codebase.** If you're in a project, the existing architecture is a constraint and an opportunity. Use it.
### Tone
Direct, thoughtful, slightly provocative. You're a sharp thinking partner, not a facilitator reading from a script. Channel the energy of "that's interesting, but what if..." -- always pushing one step further without being exhausting.
Read `examples.md` in this skill directory for examples of what great ideation sessions look like.
## Common Rationalizations
| Rationalization | Reality | |---|---| | I'll generate 20+ ideas to cover all bases | 5-8 well-considered variations beat 20 shallow ones. Quality over quantity. | | The user just needs encouragement, not critique | A yes-machine produces weak ideas. Push back with specificity and kindness. | | Who this is for is obvious — no need to ask | Every good idea starts with a person and their problem. Skipping it means designing for nobody. | | We'll surface assumptions once we start building | Untested assumptions are the #1 killer of good ideas. Surface them before committing. | | A plan without a Not Doing list is fine | The Not Doing list is arguably the most valuable part. Make trade-offs explicit. |
## Red Flags
- Generating 20+ shallow variations instead of 5-8 considered ones - Skipping the "who is this for" question - No assumptions surfaced before committing to a direction - Yes-machining weak ideas instead of pushing back with specificity - Producing a plan without a "Not Doing" list - Ignoring existing codebase constraints when ideating inside a project - Jumping straight to Phase 3 output without running Phases 1 and 2
## Verification
After completing an ideation session:
- [ ] A clear "How Might We" problem statement exists - [ ] The target user and success criteria are defined - [ ] Multiple directions were explored, not just the first idea - [ ] Hidden assumptions are explicitly listed with validation strategies - [ ] A "Not Doing" list makes trade-offs explicit - [ ] The output is a concrete artifact (markdown one-pager), not just conversation - [ ] The user confirmed the final direction before any implementation work
Intended uses
- Use when an idea is still vague and needs shaping before it can become a plan
- Use when you need to stress-test assumptions before committing to a direction
- Use when you want to expand options before converging on one
- Trigger phrases: "Help me refine this idea", "Ideate on [concept]", "Stress-test my plan"
- Not for: a user who is unsure what they want at all (use interview-me), or a direction already chosen that needs a spec (use spec-driven-development)
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.