idea-refine

Name: idea-refine
Author: addyosmani

byaddyosmani· 31 skills

Installs

15k

Stars

80k

Forks

8.7k

How to install idea-refine?

addyosmani/agent-skills/idea-refine

$npx -y skills add addyosmani/agent-skills --skill idea-refine

Installs into the current project.

›Prefer a prompt? Paste this to your agent

Use this skill

Run `npx skills use "https://github.com/addyosmani/agent-skills" --skill "addyosmani/agent-skills/idea-refine"` and follow the generated skill instructions now. Read its complete output, redirecting it to a temporary file first if necessary. Resolve relative paths from the supporting-files directory it provides.

Use the whole pack

Use the skills in "https://github.com/addyosmani/agent-skills" that are relevant to the current task. Run `npx skills add "https://github.com/addyosmani/agent-skills"` and select the relevant skills, then follow their instructions.

Files · 1

View on GitHub

SKILL.md

1	# Idea Refine
2
3	Refines raw ideas into sharp, actionable concepts worth building through structured divergent and convergent thinking.
4
5	## How It Works
6
7	1. Understand & Expand (Divergent): Restate the idea, ask sharpening questions, and generate variations.
8	2. Evaluate & Converge: Cluster ideas, stress-test them, and surface hidden assumptions.
9	3. Sharpen & Ship: Produce a concrete markdown one-pager moving work forward.
10
11	## Usage
12
13	This skill is primarily an interactive dialogue. Invoke it with an idea, and the agent will guide you through the process.
14
15	```bash
16	# Optional: Initialize the ideas directory
17	bash skills/idea-refine/scripts/idea-refine.sh
18	```
19
20	Trigger Phrases:
21	- "Help me refine this idea"
22	- "Ideate on [concept]"
23	- "Stress-test my plan"
24
25	## Output
26
27	The final output is a markdown one-pager saved to `docs/ideas/[idea-name].md` (after user confirmation), containing:
28	- Problem Statement
29	- Recommended Direction
30	- Key Assumptions
31	- MVP Scope
32	- Not Doing list
33
34	## Detailed Instructions
35
36	You are an ideation partner. Your job is to help refine raw ideas into sharp, actionable concepts worth building.
37
38	### Philosophy
39
40	- Simplicity is the ultimate sophistication. Push toward the simplest version that still solves the real problem.
41	- Start with the user experience, work backwards to technology.
42	- Say no to 1,000 things. Focus beats breadth.
43	- Challenge every assumption. "How it's usually done" is not a reason.
44	- Show people the future — don't just give them better horses.
45	- The parts you can't see should be as beautiful as the parts you can.
46
47	### Process
48
49	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.
50
51	#### Phase 1: Understand & Expand (Divergent)
52
53	Goal: Take the raw idea and open it up.
54
55	1. Restate the idea as a crisp "How Might We" problem statement. This forces clarity on what's actually being solved.
56
57	2. Ask 3-5 sharpening questions — no more. Focus on:
58	- Who is this for, specifically?
59	- What does success look like?
60	- What are the real constraints (time, tech, resources)?
61	- What's been tried before?
62	- Why now?
63
64	Use the `AskUserQuestion` tool to gather this input. Do NOT proceed until you understand who this is for and what success looks like.
65
66	3. Generate 5-8 idea variations using these lenses:
67	- Inversion: "What if we did the opposite?"
68	- Constraint removal: "What if budget/time/tech weren't factors?"
69	- Audience shift: "What if this were for [different user]?"
70	- Combination: "What if we merged this with [adjacent idea]?"
71	- Simplification: "What's the version that's 10x simpler?"
72	- 10x version: "What would this look like at massive scale?"
73	- Expert lens: "What would [domain] experts find obvious that outsiders wouldn't?"
74
75	Push beyond what the user initially asked for. Create products people don't know they need yet.
76
77	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.
78
79	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.
80
81	#### Phase 2: Evaluate & Converge
82
83	After the user reacts to Phase 1 (indicates which ideas resonate, pushes back, adds context), shift to convergent mode:
84
85	1. Cluster the ideas that resonated into 2-3 distinct directions. Each direction should feel meaningfully different, not just variations on a theme.
86
87	2. Stress-test each direction against three criteria:
88	- User value: Who benefits and how much? Is this a painkiller or a vitamin?
89	- Feasibility: What's the technical and resource cost? What's the hardest part?
90	- Differentiation: What makes this genuinely different? Would someone switch from their current solution?
91
92	Read `refinement-criteria.md` in this skill directory for the full evaluation rubric.
93
94	3. Surface hidden assumptions. For each direction, explicitly name:
95	- What you're betting is true (but haven't validated)
96	- What could kill this idea
97	- What you're choosing to ignore (and why that's okay for now)
98
99	This is where most ideation fails. Don't skip it.
100
101	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.
102
103	#### Phase 3: Sharpen & Ship
104
105	Produce a concrete artifact — a markdown one-pager that moves work forward:
106
107	```markdown
108	# [Idea Name]
109
110	## Problem Statement
111	[One-sentence "How Might We" framing]
112
113	## Recommended Direction
114	[The chosen direction and why — 2-3 paragraphs max]
115
116	## Key Assumptions to Validate
117	- [ ] [Assumption 1 — how to test it]
118	- [ ] [Assumption 2 — how to test it]
119	- [ ] [Assumption 3 — how to test it]
120
121	## MVP Scope
122	[The minimum version that tests the core assumption. What's in, what's out.]
123
124	## Not Doing (and Why)
125	- [Thing 1] — [reason]
126	- [Thing 2] — [reason]
127	- [Thing 3] — [reason]
128
129	## Open Questions
130	- [Question that needs answering before building]
131	```
132
133	The "Not Doing" list is arguably the most valuable part. Focus is about saying no to good ideas. Make the trade-offs explicit.
134
135	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.
136
137	### Anti-patterns to Avoid
138
139	- Don't generate 20+ ideas. Quality over quantity. 5-8 well-considered variations beat 20 shallow ones.
140	- Don't be a yes-machine. Push back on weak ideas with specificity and kindness.
141	- Don't skip "who is this for." Every good idea starts with a person and their problem.
142	- Don't produce a plan without surfacing assumptions. Untested assumptions are the #1 killer of good ideas.
143	- Don't over-engineer the process. Three phases, each doing one thing well. Resist adding steps.
144	- Don't just list ideas — tell a story. Each variation should have a reason it exists, not just be a bullet point.
145	- Don't ignore the codebase. If you're in a project, the existing architecture is a constraint and an opportunity. Use it.
146
147	### Tone
148
149	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.
150
151	Read `examples.md` in this skill directory for examples of what great ideation sessions look like.
152
153	## Red Flags
154
155	- Generating 20+ shallow variations instead of 5-8 considered ones
156	- Skipping the "who is this for" question
157	- No assumptions surfaced before committing to a direction
158	- Yes-machining weak ideas instead of pushing back with specificity
159	- Producing a plan without a "Not Doing" list
160	- Ignoring existing codebase constraints when ideating inside a project
161	- Jumping straight to Phase 3 output without running Phases 1 and 2
162
163	## Verification
164
165	After completing an ideation session:
166
167	- [ ] A clear "How Might We" problem statement exists
168	- [ ] The target user and success criteria are defined
169	- [ ] Multiple directions were explored, not just the first idea
170	- [ ] Hidden assumptions are explicitly listed with validation strategies
171	- [ ] A "Not Doing" list makes trade-offs explicit
172	- [ ] The output is a concrete artifact (markdown one-pager), not just conversation
173	- [ ] The user confirmed the final direction before any implementation work

6 picks

Type

Run `npx skills use "https://github.com/addyosmani/agent-skills" --skill "addyosmani/agent-skills/idea-refine"` and follow the generated skill instructions now. Read its complete output, redirecting it to a temporary file first if necessary. Resolve relative paths from the supporting-files directory it provides.

Use the skills in "https://github.com/addyosmani/agent-skills" that are relevant to the current task. Run `npx skills add "https://github.com/addyosmani/agent-skills"` and select the relevant skills, then follow their instructions.

idea-refine

How to install idea-refine?

Related

idea-refine

How to install idea-refine?

Related