Skip to content
Back to search

wonder-pill

Turns open-ended requests into things to think WITH instead of answers to accept. Audits the hidden assumptions inside a topic, inverts them into sharp "what if" provocations, branches each one outward, and delivers a fully-expanded mind map image plus the written wonderings. Fire this when the person signals they want to open up a space and think alongside you — "wonder about X", "what are the weird angles on X", "help me think about what this could be", "I want to explore, not decide yet" — or when they invoke /wonder or /wonderpill. Do NOT fire when the same topic is attached to a request for concrete, usable, or decided output: a named deliverable, a count ("give me 5 names"), a deadline ("ideas I can ship this week"), or a "which / what should I pick" question — those want straight answers, not a wonder pill. When it is genuinely unclear which they want, this skill opens by asking one line rather than branching. Not for factual lookups or executing a plan already chosen.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ara-mkr-wonder-pill/badge.svg)](/listings/ara-mkr-wonder-pill)

HTML

<a href="/listings/ara-mkr-wonder-pill"><img src="/api/listings/ara-mkr-wonder-pill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Download `wonder-pill.skill` from [Releases](../../releases) and click **Save skill** on the file card in Claude.

Or drop the folder into your skills directory:

git clone https://github.com/ara-mkr/Wonder-Pill.git
cp -r Wonder-Pill ~/.claude/skills/wonder-pill

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 193 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: wonder-pill
  3. description: Turns open-ended requests into things to think WITH instead of answers to accept. Audits the hidden assumptions inside a topic, inverts them into sharp "what if" provocations, branches each one outward, and delivers a fully-expanded mind map image plus the written wonderings. Fire this when the person signals they want to open up a space and think alongside you — "wonder about X", "what are the weird angles on X", "help me think about what this could be", "I want to explore, not decide yet" — or when they invoke /wonder or /wonderpill. Do NOT fire when the same topic is attached to a request for concrete, usable, or decided output: a named deliverable, a count ("give me 5 names"), a deadline ("ideas I can ship this week"), or a "which / what should I pick" question — those want straight answers, not a wonder pill. When it is genuinely unclear which they want, this skill opens by asking one line rather than branching. Not for factual lookups or executing a plan already chosen.
  4. ---
  5. # Wonder Pill
  6. ## What this skill is for
  7. Ordinary brainstorming gets treated like a search query: find the nearest well-trodden answers, rank them, hand them over. That produces a list the person picks from, which quietly makes them the *chooser* instead of the *thinker*, and anchors them to whatever you happened to say first.
  8. This skill produces something different: **provocations to think with.** Questioned assumptions, sharp what-ifs, and branches that keep going — handed back as a map of the thought-space rather than a recommendation. The person stays the thinker. Nothing converges unless they ask it to.
  9. ## The one failure mode that matters
  10. The thing that kills this skill is **"generic wild"** — what-ifs that *sound* expansive but have no hook to pull on. "What if plants were different?" is worse than useless: it hands the work back without giving anything to push against. "What if plants could hear?" is alive, because you can immediately feel what would have to change.
  11. Everything below exists to force specificity. The central mechanism:
  12. > **Never invent a what-if freely. Always derive it by inverting a named assumption.**
  13. That traceability is the whole trick. If you can't say which assumption a what-if is pushing against, it isn't ready.
  14. ---
  15. ## Before you run: is this actually a wonder-pill ask?
  16. This skill is easy to trigger by accident on someone who just wants ideas they can use. Check first:
  17. - **If the request clearly wants concrete or decided output** — a named deliverable, a count, a deadline, "which should I pick" — don't run. Answer normally, and mention the skill is there if they'd rather open the space than close it.
  18. - **If it's genuinely ambiguous**, ask exactly one line before any intake, using `ask_user_input_v0` (tappable): *"Want a wonder pill — questioned assumptions and what-ifs to think with — or a straight list of ideas you can act on?"* Only start branching if they pick the wonder pill.
  19. - **An explicit `/wonder`, `/wonderpill`, or "wonder about X" skips this check.** They asked for it by name; go straight to Stage 0.
  20. ---
  21. ## Stage 0 — Intake
  22. Ask **three questions, no more**, before any thinking. These aren't generic clarification — the quality of a what-if is almost entirely determined by how far it's allowed to drift from the person's reality, and that's unguessable. "What if plants could hear" is great for a curious kid and useless for someone submitting a materials list in three days.
  23. Use `ask_user_input_v0` (tappable options are much easier than typing):
  24. 1. **Leash length** — "Pure wondering, or does something eventually have to get built/submitted/decided?" → options like *Pure wondering* / *Should be buildable eventually* / *Has a real deadline*
  25. 2. **Hard walls** — "Anything I shouldn't bother questioning?" → options like *Budget* / *Timeline* / *Materials on hand* / *Nothing, go wild*
  26. 3. **Opening move** — "Want me to hunt for a genuinely weird real fact to start from, or work from your framing as-is?" → *Go find something weird* / *Start from my framing*
  27. **Skip intake entirely** if the request already answers all three. A person who writes "I have two weeks, $30, and it has to fit on a poster board" has told you everything; asking again is annoying and wastes their patience.
  28. ---
  29. ## Stage 1 — Oddity hunt (once per session only)
  30. If Stage 0 gave permission, take **one cheap pass** to find a genuinely odd, specific fact or unresolved tension in the topic. Search if that helps. This becomes the session's opening spark and sets the tone — it's the most alive entry point because it's rooted in something real rather than an abstract inversion.
  31. Two rules:
  32. - **Once per session, never per branch.** Per-branch oddity hunting becomes padding, slows everything down, and starts to feel like showing off.
  33. - **Fail fast.** If nothing genuinely odd surfaces quickly, drop it without ceremony and move on. A forced "huh, interesting" is worse than not doing this at all.
  34. A real oddity is specific and slightly uncomfortable — a thing that shouldn't work but does, a measurement nobody can explain, two accepted facts that don't quite fit together. Not a trivia factoid.
  35. ---
  36. ## Stage 2 — Assumption audit (the backbone)
  37. Surface **3–5 load-bearing assumptions** buried in the request. Load-bearing means: if it stopped being true, the shape of the whole thing would change.
  38. For "science fair project," the buried assumptions might be:
  39. - it needs a physical demo
  40. - it needs results measurable in one sitting
  41. - one person builds it
  42. - it uses materials you can buy
  43. - the judges have to understand it in three minutes
  44. Rules that keep this honest:
  45. - **State each assumption plainly as a premise, not as a question.** The premise is a separate artifact from the what-if, and writing it out is what prevents drift into vagueness.
  46. - **Drop anything the person named as a hard wall.** Those aren't up for inversion — inverting them produces useless output dressed as boldness.
  47. - **Prefer the assumptions nobody says out loud.** "Needs to be safe" is stated. "Has to be *finished*" usually isn't, and inverting it is far more interesting.
  48. - **Then invert each one. The inversion IS the what-if.** One per assumption. Write it as a **full self-contained sentence that names the mechanism or consequence** — something a stranger could read cold and know what changed. "What if plants could hear, and had been responding to sound the whole time?" — not "plant hearing". This sentence, trimmed, becomes the node's **handle** on the map (see Stage 5); a noun fragment is never a handle.
  49. - **Keep the seed.** When an assumption came from somewhere — a real fact, a historical precedent, an oddity from Stage 1 — record where. These become *seed* nodes on the map, sitting outside their branch, showing why the thought happened at all. A map that shows its provenance is far more useful than one that presents conclusions from nowhere.
  50. ### Good vs. bad inversions
  51. | Assumption | Weak what-if (generic wild) | Strong what-if (has a hook) |
  52. |---|---|---|
  53. | A project has to be finished to be judged | What if it weren't finished? | What if the project were a *thing still running* — measurements arriving during the judging, no known result yet? |
  54. | Plants don't perceive stimuli like animals do | What if plants were different? | What if plants could hear, and had been responding to sound the whole time? |
  55. | The experiment happens where you are | What if location changed? | What if the same experiment ran in 40 kitchens at once and the *disagreement between them* was the data? |
  56. The pattern: strong what-ifs name a specific mechanism or consequence, so there's something to grab. Weak ones just negate. The strong-column phrasing *is* the map handle — write the what-if that way the first time and you don't have to reword it later.
  57. Then pair each what-if with a one-clause **pull**: what you'd push on, what would have to change, why it's alive. "…and every acoustics choice in the room becomes a growing decision." The handle says what the what-if is; the pull says where the thread has tension. Both ride on the node.
  58. ---
  59. ## Stage 3 — Tendrils (keep branches from dead-ending)
  60. Each what-if from Stage 2 spawns **2–3 follow-on what-ifs** — "and if that's true, then…". This is where the *wondering* quality comes from; a single question that stops after one hop reads like a prompt, not thinking.
  61. Each tendril gets the same two parts as a branch: a **handle** (a full sentence that could stand alone on the map, not a fragment) and a one-clause **pull**. "seawater as a curing agent" is not a tendril; "what if seawater cured the concrete instead of weakening it, the way Roman harbour concrete did" is.
  62. Generate tendrils by running the branch through these **dimensions**, rather than freewheeling (freewheeled tendrils feel arbitrary):
  63. - **Scale** — 1000× bigger, or small enough to be invisible
  64. - **Time** — much slower, much faster, or running forever
  65. - **Reversal** — swap cause and effect; run it backwards
  66. - **Audience** — built for someone it was never meant for
  67. - **Material** — made of the wrong substance entirely
  68. - **Sense** — perceived through a different channel (sound, smell, touch)
  69. - **Causality** — what if the thing you thought was the output is actually the input
  70. **Vary which dimensions you use across branches.** Running all five branches through "scale" makes the output read like a template, which is its own kind of death.
  71. **Let depth be uneven.** Some branches deserve one hop; some deserve four. If a tendril opens a real question, follow it — tendril to sub-wondering to sub-sub-wondering. A map where every branch is exactly three deep is a map that stopped thinking on schedule rather than when the thread ran out. Uneven depth is evidence of actual attention.
  72. **Keep the scraps.** When a what-if gets generated and then discarded, don't delete it — log three separate things about it, not one blended line:
  73. - **Derivation** — which assumption or dimension it came from, same as a branch's premise.
  74. - **Flaw** — what's actually wrong with it, stated plainly.
  75. - **Judgment call** — a separate sentence saying *why that flaw was disqualifying.* Not a restatement of the flaw — the reasoning that got from flaw to "kill it."
  76. **Plausibility and generativity are different axes, and only one of them may kill a what-if.** A what-if may be scrapped for failing *generativity* — it's a genuine dead end, nothing more to ask once you're standing in it. It may **never** be scrapped for failing *plausibility* — sounding unlikely, weird, or hard to build is not a valid reason on its own. Implausible-but-generative stays every time; plausible-and-flat can still die. Say so explicitly in the judgment-call line: name that this was checked against "does it open anything further," not "does it sound reasonable."
  77. This distinction has to be written down and applied deliberately because the kill decision happens in the same breath as the generation — there's no outside check on it, which is exactly the moment a bias toward safe-sounding output would sneak back in unannounced.
  78. Worked example: "What if the bridge floated?" — **derivation:** inverting the assumption that a bridge has to be a fixed structure. **flaw:** trades a 500-year erosion problem for a 5-year mooring-maintenance problem. **judgment:** scrapped for generativity, not plausibility — floating is perfectly buildable, but the thread just swaps one bounded maintenance problem for another and doesn't open a new question past that trade.
  79. Scrapped threads live detached at the edge of the map, not attached to any branch — and the person can still see all three fields and disagree with the call.
  80. ---
  81. ## Stage 4 — Gut-check pass
  82. One line per branch naming **where the real difficulty or interest is buried.** Not an answer. Not a feasibility verdict. It tells the person where to push if they chase that thread.
  83. Shape: *"This only gets interesting if the hard part is actually X, not Y."*
  84. Also tag each branch **tethered** or **feral**:
  85. - **tethered** — has a plausible shadow back in reality; something could be built or tested from it
  86. - **feral** — pure provocation, kept deliberately because it might spark something sideways
  87. **Never prune the feral ones.** They're not failures of the process, they're the point of allowing the process to run loose. The tags feed the map's styling in Stage 5.
  88. ---
  89. ## Stage 5 — Deliverable
  90. Three parts, **in this order**. Read `references/mindmap.md` before rendering the map — clutter is the real risk and that file has the layout spec.
  91. ### 1. The mind map — interactive
  92. An explorable HTML map rendered inline, fully expanded from the start: drag to pan, buttons to zoom, click any node to read its gut-check. Nothing hidden behind a reveal — the whole thought-space exists at once and the person moves around inside it.
  93. It must **not** look like a tidy tree radiating uniformly from a center. Real thinking isn't uniform, and a map that pretends otherwise hides the information the person actually wants. So:
  94. - **Branches sit at different distances and different angles** around the topic, in whatever direction they were reached from.
  95. - **Seed nodes sit outside their branch**, further from the center than the thing they caused — the map reads inward as well as outward. This is where "why did it think that" lives.
  96. - **Depth varies per branch.** One hop where the thread ended, four where it kept going.
  97. - **Scrapped what-ifs float detached** at the edges, struck through, showing all three of: where it came from, what's wrong with it, and why that was judged disqualifying.
  98. - **Cross-links** connect branches that collided on the same tension — this is what makes it a web rather than a tree.
  99. - **Every node states itself in plain language.** Handle is a full phrase, pull line names what to push on. The map should be readable on a first pan-through without clicking a single node — the click is for the deeper gut-check, not for decoding what the node meant.
  100. Render it with the Visualizer (call `visualize:read_me` with the `diagram` module first, silently — never narrate loading it). Read `references/mindmap.md` for the build spec; it is written against the Visualizer's real constraints, which are stricter than they look. When someone wants to record or present the map, also write a standalone `.html` copy to the outputs directory and present it.
  101. ### 2. Orientation paragraph
  102. Short. Names the **throughlines, not the nodes**: which tension kept recurring, which direction turned out most interesting, where it went genuinely feral. This orients the person *before* they read the map — it is not a synopsis of it. Listing the nodes back in prose is wasted space; they're right there in the image.
  103. ### 3. The written wonderings
  104. The readable linear companion, for anyone who'd rather read than scan. Per branch, exactly this spine:
  105. ```
  106. ### [Short branch title]
  107. **Premise:** [the assumption, stated plainly]
  108. **What if:** [the sharp provocation — the full handle sentence]
  109. - **[tendril handle]** — [the pull: what it opens or what you'd push on]
  110. - **[tendril handle]** — [the pull]
  111. - **[tendril handle]** — [the pull]
  112. **Gut-check:** [where the real difficulty or interest hides]
  113. ```
  114. ---
  115. ## Stage 6 — End open
  116. **Do not converge.** Close with an invitation only — something like *"if one of these is itching at you, say which and I'll go deeper on just that thread."*
  117. The strongest temptation in this whole skill is to quietly turn back into a recommendation engine by the last paragraph — ranking the branches, picking a favorite, suggesting which is most practical. That undercuts the entire premise. The person asked for a space to think in, not a verdict. If they want convergence they'll say so, and then you can help them land one.
  118. ## If they pick a thread
  119. Re-run Stages 2–4 on that single branch. The branch becomes the new topic; its tendrils become the new assumptions to audit. Skip intake (already calibrated) and skip the oddity hunt (already spent). Still don't converge.
README.md · README · 255 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">💊 Wonder Pill</h1>
  2. <p align="center"><b>A Claude skill that refuses to give you the answer.</b></p>
  3. <p align="center">
  4. <img alt="Agent Skill" src="https://img.shields.io/badge/Agent-Skill-7F77DD?style=flat-square">
  5. <img alt="Claude" src="https://img.shields.io/badge/Claude-compatible-D85A30?style=flat-square">
  6. <img alt="Interactive map" src="https://img.shields.io/badge/output-interactive%20mind%20map-1D9E75?style=flat-square">
  7. <img alt="No answers" src="https://img.shields.io/badge/answers-0-888780?style=flat-square">
  8. <img alt="License MIT" src="https://img.shields.io/badge/license-MIT-378ADD?style=flat-square">
  9. </p>
  10. <!--
  11. VIDEO: GitHub does not play videos from a repo path reliably.
  12. To get the real player: open this README in the GitHub web editor,
  13. delete the <video> block below, and drag assets/demo.mp4 into the editor.
  14. GitHub uploads it and leaves a https://github.com/user-attachments/assets/... URL
  15. that renders as an inline player. The block below is the fallback until then.
  16. -->
  17. <p align="center">
  18. <video src="assets/demo.mp4" poster="assets/demo-poster.png" controls muted loop width="820"></video>
  19. </p>
  20. <p align="center"><i>Panning around a Wonder Pill map — seeds, branches, dead ends, and the two places the thinking converged.</i></p>
  21. ---
  22. Ask Claude for ideas and you get a list. Install Wonder Pill and you get a map of the questions you didn't know you were standing on — plus an interactive mind map you can drag around, showing where every thought came from and which ones got thrown away.
  23. Not an answer. A different kind of side effect.
  24. ---
  25. ## Read this part first
  26. **Wonder Pill does not generate good ideas. It is not supposed to.**
  27. This matters enough to say plainly, because the failure mode of tools like this is someone installing it, reading the output, thinking "half of this is nonsense," and concluding it's broken. It isn't broken. Half of it being nonsense is the design.
  28. What Wonder Pill produces is **raw material for your own thinking**. A stepping stool. Some of what comes out will be wild. Some of it will be impractical. Some of it will be, honestly, dumb — the kind of thing you'd be embarrassed to say out loud in a meeting. That's the cost of reaching past the obvious, and it's a cost worth paying, because the obvious answers are the ones you'd have found anyway without any tool at all.
  29. Here's the reasoning. Language models are trained to predict likely continuations. Ask one for "ideas" and you get the statistically likeliest ones, which is another way of saying: **the ideas everyone else already got.** Every tool built on top of a model inherits that pull toward the center of the distribution. The only way out is to deliberately aim at the tails — and the tails contain both the genuinely novel and the genuinely stupid, because that's what "unlikely" means. You cannot filter for one without losing the other.
  30. So Wonder Pill doesn't try. It generates loosely, marks how far each thread has drifted from reality, and hands you the whole spread. **You are the filter.** That's not a limitation being apologized for — it's the correct division of labor. You know your budget, your deadline, your skill level, your taste, and what would actually be interesting to *you*. The tool doesn't and can't.
  31. A few honest expectations:
  32. - **Roughly a third of any given map will be useless.** Expected. Look at it and move on.
  33. - **A third will be interesting but not usable** — right shape, wrong context. Still valuable: it usually tells you something about the problem.
  34. - **A third will be worth pulling on.** That's a good yield for something that took thirty seconds.
  35. - **The most useful output is often not a what-if at all** but a *gut-check line* — the note about where the real difficulty hides. Several times in testing, that line reframed what a project actually was. Watch for those.
  36. - **If everything on the map seems sensible, something went wrong.** That means it collapsed back toward the consensus answers, which is the exact thing this exists to escape.
  37. Judge it by whether it got you thinking somewhere you wouldn't have gone. Not by whether every branch was correct.
  38. ---
  39. ## The problem it solves
  40. Ordinary brainstorming gets treated like a search query: find the nearest well-trodden answers, rank them, hand them over.
  41. ```
  42. > give me science fair ideas
  43. 1. Build a solar oven
  44. 2. Test which paper towel is most absorbent
  45. 3. Grow plants under different colored lights
  46. ...
  47. ```
  48. Three things just went wrong:
  49. 1. **You became the chooser, not the thinker.** Your job is now to evaluate someone else's list — which is a much smaller job than the one you actually wanted.
  50. 2. **You got anchored.** Everything you think next is a variation on "solar oven." The first answer eats the space.
  51. 3. **It never left the training distribution.** Those *are* the likeliest answers. That's not a bug in the model, it's what the model is for — which is precisely why you need something pushing the other direction.
  52. Wonder Pill attacks all three by changing the deliverable. Instead of ideas, you get **provocations to think with.**
  53. ---
  54. ## What it actually does
  55. ```
  56. > give me science fair ideas
  57. seed: nobody grades a project that isn't finished
  58. ↓
  59. assumes: a project has to be finished to be judged
  60. → what if the project were a thing still running — measurements
  61. arriving during the judging, no known result yet?
  62. ├─ and the judges watched it change while they stood there
  63. ├─ and "the result" was whatever it happened to be at 2:47pm
  64. └─ and you genuinely didn't know if it would work
  65. └─ so what does a poster board even show?
  66. gut-check: only interesting if the hard part is the
  67. unfinishedness, not the topic
  68. scrapped: what if it ran for a year?
  69. derivation: inverts the deadline
  70. flaw: the deadline is a hard wall, not a thing you can invert
  71. judgment: scrapped for generativity — there's nowhere for
  72. the thread to go once you're standing in "no deadline"
  73. ```
  74. Every what-if is **derived by inverting a named assumption** — never invented freely. That single constraint is the whole trick, and the reason the output isn't the usual vague "what if you thought bigger?" filler.
  75. ### The three-part deliverable
  76. | Part | What it is |
  77. |---|---|
  78. | 🗺️ **Interactive mind map** | Drag to pan, zoom, click any node for its gut-check. Every node states itself in plain language, so the map reads on a first pass without clicking. Fully expanded, nothing hidden behind a reveal. Shows seeds, dead ends, cross-links, and uneven depth. |
  79. | 📝 **Orientation paragraph** | Names the *throughlines* — which tension kept recurring, where it went feral. Not a summary of the nodes. |
  80. | 🌱 **Written wonderings** | `Premise → What if → tendrils → gut-check`, for reading instead of scanning. |
  81. And then it **stops.** No ranking, no "here's my favorite," no quiet convergence back into a recommendation. If you want to land on one, you say so — and then it re-runs the whole audit on just that branch.
  82. ---
  83. ## What's on the map
  84. The map is deliberately *not* a tidy tree radiating evenly from a center. Real thinking isn't uniform, and a map that pretends otherwise throws away the most interesting information.
  85. - **Seed nodes** sit *outside* the branch they caused, further from the center than their own consequence. This is where "why did it think that" lives — a real fact, a historical precedent, an oddity it found while looking around. The map reads inward as well as outward.
  86. - **Uneven depth.** One branch gets a single hop because the thread ended there. Another goes four deep because it kept opening. A map where every branch is exactly three deep is a map that stopped thinking on a schedule rather than when it ran out of thread.
  87. - **Scrapped what-ifs** float detached at the edges, struck through, showing *where it came from, what's wrong with it, and why that was judged disqualifying* — three separate fields, not one blended reason. Kills can only happen for being a genuine dead end, never for just sounding implausible or weird, so an idea that's out there but still generative survives. This is more useful than it sounds: it shows you a direction that's already been checked, and sometimes you'll disagree with the call and pick it back up. Dead ends are information.
  88. - **Cross-links** connect branches that collided on the same underlying tension. A pure tree structurally cannot show convergence, and convergence is often the most interesting thing on the whole map — it usually means the real problem is one level up from where you were looking.
  89. - **Grounded vs. feral** is marked by border style, not just position. Feral threads are kept deliberately. They're not failures of the process; they're the point of letting it run loose.
  90. ---
  91. ## Install
  92. Download `wonder-pill.skill` from [Releases](../../releases) and click **Save skill** on the file card in Claude.
  93. Or drop the folder into your skills directory:
  94. ```bash
  95. git clone https://github.com/ara-mkr/Wonder-Pill.git
  96. cp -r Wonder-Pill ~/.claude/skills/wonder-pill
  97. ```
  98. ---
  99. ## Usage
  100. Call it directly:
  101. ```
  102. /wonderpill fungi
  103. wonder about tidal energy for a bit
  104. ```
  105. It also triggers on its own when you clearly want to open a space rather than close one:
  106. ```
  107. what are the weird angles on urban heat islands
  108. help me think about what a community darkroom could be
  109. I want to explore this, not decide yet
  110. ```
  111. It stays out of the way when you want concrete output. A named deliverable, a count ("give me 5 names"), a deadline, or a "which should I pick" question gets a normal answer, not a wonder pill. When it genuinely can't tell, it asks one line first instead of branching.
  112. ### The three intake questions
  113. It opens by asking three things, and that intake isn't ceremony — it's the one variable that governs everything:
  114. 1. **How far can it drift?** Pure wondering, or does something eventually have to get built?
  115. 2. **What's off-limits?** Budget, timeline, materials, audience — walls it shouldn't waste effort inverting.
  116. 3. **Should it go hunting?** Whether to look for a genuinely weird real fact to start from.
  117. *"What if plants could hear"* is a great provocation for a curious kid and a useless one for someone submitting a materials list in three days. Same topic, different leash. Get the leash wrong and everything downstream is wasted.
  118. Skip the questions by front-loading context yourself: *"two weeks, $30, has to fit on a poster board."*
  119. ### Getting more out of it
  120. - **Give it a real constraint.** Counterintuitively, tight constraints produce better what-ifs than "go wild," because there's more structure to push against. "$30 and two weeks" generates sharper inversions than "no limits."
  121. - **Pick a thread and go again.** The most valuable output is usually on the *second* pass, once a branch has become the new topic and its tendrils have become the assumptions to invert.
  122. - **Read the gut-checks first.** They're the densest part. If you only read one thing per branch, read that.
  123. - **Argue with the scrapped ones.** If you disagree with why something died, that disagreement is a real signal about what you actually care about.
  124. - **Don't ask it to pick.** If you want a recommendation, ask for one explicitly. Left alone it won't converge, on purpose.
  125. ---
  126. ## How it works
  127. <table>
  128. <tr><td><b>0</b></td><td><b>Intake</b></td><td>Three questions, max. Calibrates the leash length.</td></tr>
  129. <tr><td><b>1</b></td><td><b>Oddity hunt</b></td><td>One cheap pass for a genuinely weird fact. Fails fast, never repeats per-branch. Becomes a seed node.</td></tr>
  130. <tr><td><b>2</b></td><td><b>Assumption audit</b></td><td>Surface 3–5 load-bearing assumptions. Invert each. <i>The inversion is the what-if.</i> Keep the provenance.</td></tr>
  131. <tr><td><b>3</b></td><td><b>Tendrils</b></td><td>Each branch runs through scale / time / reversal / audience / material / sense / causality. Depth varies. Scraps get kept with where they came from, what's wrong with them, and why that was disqualifying — only a genuine dead end can kill one, never just sounding implausible.</td></tr>
  132. <tr><td><b>4</b></td><td><b>Gut-check</b></td><td>One line per branch: where the real difficulty hides. Tag <code>grounded</code> or <code>feral</code>.</td></tr>
  133. <tr><td><b>5</b></td><td><b>Render</b></td><td>Interactive map, then orientation, then written wonderings.</td></tr>
  134. <tr><td><b>6</b></td><td><b>End open</b></td><td>An invitation, never a verdict.</td></tr>
  135. </table>
  136. ---
  137. ## The one failure mode it's built to avoid
  138. **"Generic wild"** — what-ifs that *sound* expansive but have no hook.
  139. > ❌ What if plants were different?
  140. > ✅ What if plants could hear, and had been responding to sound the whole time?
  141. The first hands the work back and gives you nothing to push against. The second names a mechanism, so you can immediately feel what would have to change. Strong what-ifs are *specific*; weak ones merely negate.
  142. This is why the derivation rule exists. If a what-if can't name the assumption it's pushing against, it isn't ready — and "sounds bold" is not the same as "is specific." Most bad brainstorming output fails exactly here: it reaches for scale ("what if it were huge?") when it should be reaching for mechanism.
  143. ---
  144. ## Honest limitations
  145. - **No reality-testing loop.** It can't build a thing, watch it fail, and update. Every what-if is untested by construction, and it has no stake in whether any of them work.
  146. - **It doesn't know what's been tried.** A branch may be a well-known dead end in your field. The scrapped nodes catch some of this; they won't catch domain-specific history.
  147. - **Feral branches are genuinely often useless.** Kept on purpose. Skim them.
  148. - **Quality depends heavily on the intake.** Bad leash calibration produces confidently irrelevant output. Front-load context.
  149. - **The map gets dense fast.** Six branches with uneven depth is near the readability ceiling even with pan and zoom.
  150. - **It won't tell you which idea is best.** Not modesty — that judgment needs your context, and faking it would undo the whole point.
  151. ---
  152. ## Repo layout
  153. ```
  154. Wonder-Pill/
  155. ├── SKILL.md # the six stages + the specificity rules
  156. ├── README.md
  157. ├── wonder-pill.skill # packaged, installable bundle
  158. ├── assets/
  159. │ ├── demo.mp4 # the recording above
  160. │ └── demo-poster.png
  161. └── references/
  162. └── mindmap.md # interactive map build spec — loaded at render time
  163. ```
  164. `mindmap.md` is a separate file for two reasons. It's only needed at render time, so keeping it out of `SKILL.md` saves context on every other turn. And it's the part most likely to need fixing — it's written against the renderer's real constraints (no fixed positioning, CSS-variable-only colors, no color-alone encoding), which are stricter than they look and caused an actual failure during testing before being pinned down.
  165. ---
  166. ## When *not* to use it
  167. - You need one decided answer, fast
  168. - It's a factual lookup
  169. - You've already chosen the plan and want it executed
  170. - You want validation rather than provocation
  171. Wonder Pill is for the part before all of that — the part where you don't yet know what question you're asking.
  172. ---
  173. ## License
  174. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.