# Ideate > Structured idea generation for a project or a blank-slate problem — ideas worth pursuing, not the first one that sticks. Grounds in the current repo (AGENTS.md/README) or a freeform problem, then diverges across named lenses (adjacent user, removed constraint, inversion, and more) so a run yields range, not ten variations of one idea. Fights premature convergence — nothing judged until the divergence quota is met — then verdicts each idea EXPLORE/PARK/DROP, where DROP is cheap. EXPLORE items become seeds for priorart (is it novel?) or feature (build it); verdicts persist in out/ideate/tracker.md so repeat runs open with what's new. Keyless. Use to generate, brainstorm, or explore ideas or new directions for a project or problem — e.g. "/ideate", "/ideate ", "brainstorm features for X". For whether an idea already exists use priorart; for competitor features use scout; for choosing between named options use verdict. - Skill: `duthaho/ideate` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add duthaho/ideate` - Raw SKILL.md: https://api.skillmd.com/api/skills/duthaho/ideate/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: duthaho (https://skillmd.com/u/duthaho) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/duthaho/ideate --- # ideate — diverge before you converge `/ideate` — generate ideas for THIS repo (reads its AGENTS.md/README) `/ideate ` — generate ideas for an arbitrary problem, no repo needed Answer one question: **what could this become that isn't obvious yet — and which of those directions actually deserves effort?** Both halves matter. A session that only sprays ideas is a whiteboard; one that judges before it has range is just the first idea wearing a verdict. The deliverable is a short list of directions each carrying its own reason to live or die. The enemy the whole skill is built against is **premature convergence** — latching onto the first plausible idea and spending the session polishing it. Every step below exists to hold divergence open long enough to be worth converging on. ## Step 0 — Frame the ground You cannot diverge from nothing; fix a starting point first. - **With a repo** (`/ideate` alone): read `AGENTS.md` (the map skill writes it), `README`, and the top-reacted open issues. Distill the project's **job in one sentence** and its **differentiation axis** — the thing it does that alternatives don't, which every later verdict is judged against. - **With a topic** (`/ideate `): restate the problem in one sentence and name the **user** and the **constraint that hurts most**. Missing pieces are assumptions — state them, don't invent facts. - Read `out/ideate/tracker.md` if it exists: ideas already generated, verdicts already made. A DROPped idea isn't re-raised unless something changed; repeat runs open with **"Since last ideate"** — what's new in the repo or problem since. **Completion criterion:** job, user, and differentiation/constraint written down before any idea is generated. ## Step 1 — Diverge (judgment forbidden here) Generate ideas by working the **lenses** in [`references/lenses.md`](references/lenses.md) — do not freehand a flat list, which is how every session collapses into variations of one idea. Take each lens in turn and force at least one idea from it, even a weak one; range comes from the lenses being different, not from trying harder on one. Hard rule: **no evaluating, ranking, or "but that won't work" until the quota is met** — aim for at least two ideas per lens worked. Judging mid- divergence is premature convergence by another name; a bad idea from an unworked lens is worth more here than a safe idea restated. **Completion criterion:** every applicable lens worked, quota met, ideas captured verbatim — no pruning yet. ## Step 2 — Cluster and sharpen Now converge, but only halfway. Group the raw ideas into clusters of the same underlying bet; within each cluster keep the sharpest single statement and fold the rest into it. Kill exact duplicates. For each survivor write one line: **what changes for the user if this exists.** An idea whose user-impact line can't be written is a DROP waiting to happen — surface that now, not after building. **Completion criterion:** a deduplicated list, each survivor with a one-line user impact. ## Step 3 — Verdict each survivor Every surviving idea gets exactly one label, with a reason: - **EXPLORE** — worth real effort next. Must clear two bars: it advances the differentiation axis (or genuinely relieves the worst constraint), and its effort is justified by that impact. "It sounds cool" clears neither. - **PARK** — plausible but not now; record the trigger that would revive it. - **DROP** — off-axis, redundant, or impact doesn't pay for effort. DROP is the cheap default; a session that EXPLOREs everything has judged nothing. Hand off cleanly: each **EXPLORE** is a ready **seed** — route it to `priorart` (does it already exist before you build?) or straight to `feature` (build it). Name the handoff in the verdict. **Completion criterion:** every survivor labeled EXPLORE / PARK / DROP with a reason, and every EXPLORE names its next skill. ## Step 4 — Persist Append the run to `out/ideate/tracker.md`: date, the frame (job + axis), and every idea with its verdict and reason — including DROPs, so they aren't re-raised next run. This is the memory that lets the next `/ideate` open with "Since last ideate" instead of regenerating the same list. **Completion criterion:** tracker written; run reproducible from it.