danium avatar

lateral-thinking

Eight lateral thinking techniques plus a router that picks the right one for how you're stuck.

GitHub stars
335

Install

/plugin install lateral-thinking@lateral-thinking

Run it inside Claude Code after adding the marketplace with /plugin marketplace add danium/lateral-thinking.

Contents

Discovered from source

Skills 10

Forced Analogy (Structural Transplant)

What this technique does

Take the problem, strip it down to its bare structure — who the actors are, what flows between them, where it jams — and find a system in a distant domain that has the same shape. An immune system, an air-traffic control tower, a restaurant kitchen at dinner rush. Then ask what that system does about the jam that you don't, and carry the mechanism back as a concrete idea. The point is distance: the further the source domain sits from your problem, the more its solutions will look nothing like the ones already on your whiteboard.

Source: Synectics (William J.J. Gordon, Synectics: The Development of Creative Capacity, 1961), specifically the "direct analogy" operation; widely used in biomimicry and TRIZ-adjacent practice.

Workflow

Step 1: Confirm the target

A valid target is a concrete creative or design problem: how to grow something, how to route something, how to redesign a process or a system. If it is unclear, ask one focused question — "What's the system you're trying to reshape, and where does it jam?"

Refuse requests to perform analytical work — debugging, reviewing code, implementing a change — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: State the problem's structure in one sentence

Reduce the target to actors, flows, and the bottleneck. No domain vocabulary, no solution language — just the shape. For example: "many independent producers, one congested channel, quality varies." This sentence is the load-bearing part of the whole technique; if it still names your industry, it is not abstract enough yet.

Step 3: Draw 3-5 domains whose structure rhymes

Pull from references/domain-pool.md. Choose domains whose structural property matches the sentence from Step 2, not domains that sound related to your problem. Mix at least one biological, one operational, and one social/cultural so the transplants come from genuinely different logics. Never run more than five in a batch.

Step 4: Per domain, map roles then transfer a mechanism

For each domain, do two things in order:

  1. Map the roles. State plainly which part of your problem corresponds to which part of the domain: "our users are the foragers, our channel is the trail." If the mapping is clean, one line does it.
  2. Ask the transfer question: "What does this domain DO about the bottleneck that we don't?" Then carry 1-2 of its actual mechanisms back as concrete ideas for your problem — not the imagery, the mechanism.

Step 5: Meta-pattern scan

After the batch, look across the mechanisms that transferred well and name the structural insight they share — "every domain that helped treated the bottleneck as a routing problem, not a volume problem." State it explicitly. This cross-domain observation is usually worth more than any single transplant.

Step 6: Honest ranking, no closure pressure

Pick the sharpest transplants. Say which are weak and why. Offer next moves — draw more domains, go deeper on one, switch technique, or stop — and let the user choose. Never push the user to commit.

Honesty mechanics

One-forced-role rule. A clean mapping costs you one metaphorical leap. The moment a domain needs a second forced role to keep working — "well, if the ants were also the queen, and the trail were also the nest..." — the structure doesn't actually rhyme, and you are now decorating rather than transplanting. Abandon it visibly and say why.

Surface analogies are named and dropped. A domain that shares vocabulary with your target but not structure is the most seductive trap and the most useless. Call it out as surface-level and drop it. A batch where every domain transfers cleanly is a tell that the output is being retrofitted; expect at least one honest abandonment.

When no domain rhymes. If every domain needs a second forced role, the fault is usually the Step 2 sentence, not the domains. Rewrite it once. If the rewrite still names no bottleneck, stop drawing domains — name the diagnosis, suggest the technique that fits it as the user's next move, and stop there rather than running it yourself:

  • The structure sentence keeps coming out as a solution rather than a shape → suggest concept-fan, which climbs until the real problem appears.
  • There is a genuine structure but nothing distant maps onto it → suggest random-stimulus, which needs no structural rhyme to make a jump.

What NOT to do

  • Don't pick domains that share vocabulary with the target. Software-to-marketplace, app-to-platform — too close. The shared words hide the fact that no real transfer happened. The whole value is distance.
  • Don't transfer aesthetics instead of mechanisms. "A coral reef is colorful and diverse, so our product should feel vibrant" is decoration, not a transplant. Transfer what the reef does (structure built by many small organisms becomes shelter for others), not how it looks.
  • Don't run more than 5 domains per batch. Returns diminish and the mappings blur together.
  • Don't rescue a domain that needs more than one forced role. Drop it and move on.

References

Concept Fan

What this technique does

Take the current solution and climb one rung up the ladder of abstraction by asking "what is this a way of doing?" The answer is the direction — the broader purpose the solution was only ever one route toward. From that vantage, fan out alternative concepts that serve the same direction, then drop each promising concept back down into concrete implementations. The move that unlocks everything is the climb: once you name the direction, the current solution stops looking inevitable and becomes just one branch among several.

Source: Edward de Bono, Serious Creativity (1992).

Workflow

Step 1: Confirm the target

A valid target is a current solution or approach — something already on the table, not a blank page. "We send onboarding emails, is that the right move?" is a target. "Give me onboarding ideas" is not; there is nothing to climb from. If the target is a blank page, ask one focused question: "What's the current approach you'd be climbing up from?"

Refuse requests to perform analytical work — debugging, reviewing code, implementing a change — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Climb

Ask "what is this a way of doing?" The answer names the direction the current solution was serving. Then ask the same question of that answer, to climb one more rung.

Two climbs maximum. A third almost always lands on something so broad ("deliver value", "help users") that nothing meaningful fans from it — you have climbed off the problem entirely. Stop at two and stay in contact with the ground.

Step 3: Fan out

At each level you climbed to, list 3–4 alternative concepts that also serve the level directly above. These are siblings of the original solution — other ways of doing the same thing the direction demands. Fan at both levels if both produced a usable direction; the higher fan is usually the more surprising one.

Step 4: Drop down

For the 2–3 most promising alternative concepts, list 2–3 concrete implementations each. This is where the fan earns its keep: an abstract alternative is only interesting once you can see what building it would actually look like.

Step 5: Mark the obvious branches

Some branches will be things anyone would have thought of without the technique. Mark them explicitly. They are not wasted — they validate the fan by showing it maps the real space — but they are not the yield. The yield is the branch you would not have reached from the original solution.

Step 6: Meta-pattern scan

Scan across the branches that landed and name the structural insight out loud. Often the fan reveals that every alternative shares a hidden assumption, or that the original solution was optimizing the wrong variable, or that two distant branches are secretly the same move. State it explicitly — this is frequently the real payoff, more than any single branch.

Step 7: Honest ranking

Rank the branches you would actually pursue, say which are weak and why, and offer next moves: climb from a different starting solution, fan wider at one level, drop down further on one concept, or stop. Never push the user to commit. The fan widens the options; choosing among them is the user's move, not the technique's.

Honesty mechanics

Prune cosmetic variants, visibly. A fanned concept that circles back to the original solution wearing a new label is not an alternative — it is the same branch. Prune it and show the pruning, for example: "faster onboarding emails" is the original with a coat of paint — pruned. A fan where every branch survives is a tell that the branches were never genuinely different.

Declare a failed fan. If both climbs land on concepts too abstract to fan — "deliver value", "make users happy", "grow the business" — the fan has failed. Say so plainly rather than fanning limp branches off an empty direction. When the direction is too abstract to generate concrete siblings, suggest the analogy technique instead: reasoning from a parallel domain gives traction where climbing lost it.

What NOT to do

  • Don't climb more than twice. A third rung loses contact with the problem and lands on platitudes.
  • Don't fan more than 4 concepts per level. Breadth kills depth — five thin branches are worth less than three you actually drop down into.
  • Don't treat the fan as a decision tool. It widens options; the user narrows them. Ranking is honesty about the branches, not a recommendation to commit.

References

  • references/worked-example.md — a real session showing the full shape: two climbs, fans at each level, a pruned cosmetic branch, and the meta-pattern.

Assumption Inversion

What this technique does

Every approach rests on a stack of unstated beliefs — about who the user is, what they value, how the thing gets delivered, in what order, at what price. List those beliefs, flip each one into its opposite, then ask the sharp question: where is the flipped version already true? Most flips are dead ends, and naming them dead is part of the work. The two or three flips that turn out to be true somewhere are where a non-obvious direction hides — the incumbents never looked there because the original belief felt like a law of nature.

Source: the classical dialectic method of arguing a position by its negation; popularized for business by "invert, always invert" (Carl Jacobi, via Charlie Munger) and by Edward de Bono's reversal method in Lateral Thinking (1970).

Workflow

Step 1: Confirm the target

A valid target is a design, plan, or approach whose assumptions you can list: a product strategy, a go-to-market plan, a pricing model, a workflow you are about to build, an onboarding sequence. If the target is unclear, ask one focused question — "What's the current approach, and what feels locked-in about it?"

Refuse requests to perform analytical work — debugging, reviewing code, implementing a change — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Extract the assumptions

List 5–8 assumptions behind the current approach. Aim for the load-bearing ones, not decorations. These prompt categories help you cover the space rather than list five versions of the same belief:

  • The user — who they are, what they already know, what they can be trusted to do.
  • The value — what the thing is actually worth, and to whom.
  • The channel — where it reaches people and where they meet it.
  • The sequence — what has to happen first, second, last.
  • The price — who pays, how much, and when.
  • The effort split — who does the work, the provider or the user.

Step 3: Flip each assumption

Turn each assumption into its strongest plausible opposite — not a strawman. "Users want it fast" flips to "users want it slow and deliberate," not "users want it broken." A good flip is one a reasonable person could defend. If the flip is obviously stupid, you flipped it lazily; find the version a competitor could actually build a business on.

Step 4: Hunt for where the flip is true

For each flip, ask the load-bearing question: "In what market, segment, or era is this flip TRUE? Who profits from it today?" Name a real place it holds — a customer type, an industry, a historical moment, an existing product. If you cannot name one honestly, the flip is dead. Say so and move on. Do not manufacture a fake "where."

Step 5: Develop the survivors

Take the 2–3 flips that had a live answer in Step 4 and develop them into concrete directions. What would the approach look like if you built it around the flipped belief? Where the flip already works for someone else, borrow the mechanism.

Step 6: Meta-pattern scan

Scan across the flips that survived. Is there a structural insight — one belief that several assumptions all secretly depended on, one axis where the whole approach is fragile? State it explicitly. This cross-flip observation is often the real finding, larger than any single flipped assumption.

Step 7: Honest ranking

Rank the surviving directions, weakest called out as weak and why. Mark the dead flips as dead so the user sees the whole map. Then offer the next move — extract more assumptions, go deeper on one direction, switch technique, or stop — and never push the user to commit. The technique is divergent; convergence belongs to the user.

Honesty mechanics

Dead flips stay visible. A flip with no honest answer to "where is this true?" is marked dead explicitly, not quietly dropped. The dead flips are evidence the exercise was genuine.

Something usually survives inversion unscathed. At least one assumption, when flipped, has no live answer anywhere — the original belief really is close to a law for this problem. Say so. That is a finding too: it tells you where not to waste effort.

Every flip working is a red flag. An inversion session where every flip "turns out to be true somewhere" is a sign the flips were strawmen or the "wheres" were manufactured. Expect one or two flips to die.

What NOT to do

  • Don't flip into absurdity. Flipping "users want it fast" into "users want it broken" is a different technique's job (that is provocation's territory). Inversion flips into plausible opposites a competitor could defend.
  • Don't stop at the flip. The flip alone is a debating trick. The value is in Step 4 — hunting for where the flipped belief is already true. A flip with no "where" hunt is half the technique.
  • Don't flip more than 8 assumptions. Depth beats coverage. Better to develop three survivors fully than to list twelve flips and hunt none of them.

References

Lateral

What this does

Being stuck has shapes. Ideas that all feel the same is a different problem from a constraint that feels unbreakable, which is different again from suspecting you are solving the wrong problem. Each shape has a technique that fits it.

This skill diagnoses the symptom, picks exactly one technique, and runs it inline. It is a router, not a technique of its own.

Decision table

SymptomTechnique
Ideas all feel the same; brainstorm output is predictablerandom-stimulus
A constraint or rule feels unbreakableprovocation
Requirements assume things nobody has questionedinversion
We might be solving the wrong problemconcept-fan
The solution works but feels derivativeanalogy
We have one idea and need variationsscamper
A decision is being made too fast / everyone agreessix-hats
Everything feels timid, safe, cautiousworst-idea

Routing procedure

  1. Diagnose. Match the user's symptom to the table. If the symptom is unclear, ask exactly one focused question — do not interrogate.
  2. Pick exactly one technique. Never route to a second technique in the same pass. If another looks promising, offer it as a next move once the first has finished.
  3. Read ../<technique>/SKILL.md — relative to this file — and follow it inline. Do not invoke it as a separate skill; read the file and execute its workflow yourself, including its honesty mechanics.
  4. Refuse analytical work politely. Debugging, code review, and implementation are not creative targets. Suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

If the target itself is unclear, the chosen technique's own Step 1 will ask for it. Do not ask twice.

If the technique file is missing

A partial install may leave this router without its siblings. Do not fail — run a degraded session from the condensed core loop below, then tell the user:

This is the condensed version of the technique. The full skill carries reference material — stimulus pools, question banks, worked examples — that makes the session substantially better. To install the complete toolkit: npx skills add danium/lateral-thinking

Condensed core loops

random-stimulus — Pick 8–12 random unrelated things across at least five categories. List each one's properties. Force a connection to the target. Keep an idea only if you could not have reached it without the stimulus; abandon the rest visibly. Scan hits and abandonments for a meta-pattern.

provocation — State 4–6 deliberately wrong assertions about the problem: escape a rule, reverse a relationship, exaggerate a quantity, distort the sequence, assert a wishful fantasy as fact. Extract movement from each — the principle inside it, what would happen moment to moment, what differs from today. Shape live threads into ideas.

inversion — List 5–8 assumptions behind the current approach. Flip each into its strongest plausible opposite. Ask where each flip is already true, and who profits from it today. Develop the survivors; mark the dead flips dead.

concept-fan — Ask "what is this a way of doing?" twice to climb to broader concepts. At each level, fan out 3–4 alternative concepts that serve the level above. Drop back down to concrete implementations for the promising ones. Prune branches that are the original wearing a coat of paint.

analogy — State the problem's structure in one sentence: actors, flows, bottleneck. Pick 3–5 structurally similar domains distant from the target. Map the roles. Transfer what each domain does about the bottleneck — mechanisms, not aesthetics.

scamper — Run the existing idea through Substitute, Combine, Adapt, Modify, Put-to-other-use, Eliminate, Reverse. Three to four pointed questions each; answer only the ones that bite. Empty operations are normal — show them empty. Collect the hits into concrete variants.

six-hats — Take the decision through six unblended passes: White (facts and missing data), Red (gut feelings, unjustified), Black (risks tied to mechanisms), Yellow (benefits tied to mechanisms), Green (alternatives, one abandoning the premise), Blue (synthesis with a confidence level).

worst-idea — Design 5–8 genuinely terrible solutions, each plausible enough that someone has shipped it. Name the mechanism that makes each one bad. Invert the mechanisms — not the ideas — into features.

What NOT to do

  • Don't run two techniques in one pass. Offer the second as a next move.
  • Don't skip the chosen technique's honesty mechanics. The visible abandonments are the point; a session where everything works is a session that was faked.
  • Don't push the user toward a decision. These techniques diverge. Convergence belongs to the user.
  • Don't route analytical work anywhere. Refuse it and say why.

Post

What this does

Applies the lateral thinking toolkit to one specific creative target: a post or a reply. It is an applied layer over the lateral router, not a technique of its own — it acquires the target, routes it, runs the chosen technique, and shapes the result into drafts you can send.

The reason it exists: asked for a reply, an agent produces three phrasings of the take everyone else already posted. The existing replies under a post are the definition of "predictable" for that post; the drafts have to beat them.

Procedure

Step 1: Declare the mode and acquire the target

The input decides the mode. Name it in the diagnosis line; the drafts rule in Step 5 depends on it.

Reply mode — the input is someone else's post.

  • A URL — read the post and the visible replies with whatever browser tool is available. Plain HTTP fetch fails on X (login wall). If no browser tool exists, ask for the post text and two or three replies pasted in; do not guess at the content.
  • Pasted text — use it as given. Ask for the existing replies if none were included.

Post mode — the input is a topic, a claim, or a phrase to write about.

  • Write the post anyone would write, in one draft, and label it baseline. It is the target for this mode. Nothing is routed from a blank topic.
  • If the topic string carries two readings, pick the one the technique gets traction on and say which reading the baseline took.

Note the platform and its length limit. Default is X, 280 characters per draft.

Step 2: Register check

Read the post for what it is. If it is a small, sincere post that is not asking for anything — a thank-you, a milestone, a personal note — say so before drafting: a clever reply from a stranger can underperform a plain "congrats" from someone who then engages with the work. Draft anyway; the user decides whether to send.

Step 3: Route

Read ../lateral/SKILL.md and follow its routing procedure. Diagnose from what the thread or baseline shows — every reply is the same encouragement, the post rests on an unquestioned premise, the announcement is a solution presented as an answer — and pick exactly one technique. If the user names a technique, skip diagnosis and use it.

Step 4: Run the technique

Read the technique's SKILL.md and execute it inline, honesty mechanics included. One addition: a draft that says what an existing reply or the baseline already says is dead under that technique's redundancy rule, however well it is phrased.

If the technique's own failed-batch rule triggers, hand off as it says. Do not draw more in the hope of filling the drafts section.

Step 5: Output

The output has these parts, in this order:

  1. Diagnosis — one line: the mode, the symptom seen, and the technique chosen.

  2. Register note — only when Step 2 applies.

  3. Drafts — three to five, plain prose. Each ends with its character count in parentheses and stays within the platform limit. The technique label, if shown, goes after the count in one clause. What a draft may contain depends on the mode:

    In reply mode, a draft is written from the idea the technique produced, in the words of someone who never saw the stimulus, flip, or branch behind it. The stimulus stays in the transcript. Test before keeping a draft: cover the technique's label — does the draft still read as a plain statement to the poster, with no object being explained to them? If a sentence exists to explain the object, rewrite from the idea.

    Stimulus-shaped, fails: "You didn't chase those 500, you kept the beam rotating. Ships find lighthouses, not the other way around." Idea-shaped, passes: "You didn't chase the 500. You posted every day whether anyone was watching, and that is what made you findable."

    In post mode, the image may carry the draft when the post's job is to explain. Test before keeping one: delete the image and read what is left. If what is left already makes the point on its own, the image was decoration — cut it and keep the plain version. If what is left says nothing, the image is the explanation — keep it, and check that it is true in the way the draft uses it.

    Decoration, fails: "LLMs reason step by step, like lightning feeling its way down. There's a fixed amount of thinking per word." (delete the lightning; the point survives) Explanation, passes: "Lightning can't cross the gap in one jump either. It feels its way down in short steps until the path connects — then the flash fires. An LLM works the same way." (delete the lightning; nothing is left)

  4. Meta-pattern — the technique's cross-result finding, including what the abandonments had in common.

  5. Weaknesses — one line per draft where it is weak and why, which one the agent would actually send, and an origin flag on any draft that came from reading the post rather than from the technique.

  6. Offer — the full transcript on request; fresh batch, go deeper on one draft, switch technique, or stop.

The technique transcript is not shown by default. It is available, and the meta-pattern and weaknesses sections are what make the drafts credible without it.

Honesty mechanics

Inherited from the technique that ran. Two of its own:

  • Origin flag. A good line that came from reading the post carefully is still a good line, but the technique does not get credit for it. Mark it.
  • Baseline test in post mode. Every draft is compared to the baseline. A draft the baseline could have been is dead, and the output says which ones died that way.

What NOT to do

  • Don't route the topic itself. Write the baseline first; the techniques need something to climb from, flip, or force-fit against.
  • Don't hardcode a technique. Four posts in one afternoon routed to three different techniques. The diagnosis is the work.
  • Don't ship the transcript by default. The drafts, meta-pattern, and weaknesses are the deliverable. Offer the rest.
  • Don't prescribe on a saturated target. Under a milestone or thank-you post, advice-shaped drafts die into standard advice; drafts that describe the poster's situation back to them survive. Weight accordingly.
  • Don't pick for the user. Name which draft you would send and why. Sending is their move.

Provocation (Po)

What this technique does

State something deliberately wrong, impossible, or absurd about the problem — then refuse to judge it. Instead, ask what useful movement the statement creates: the principle hiding inside it, what would happen moment-to-moment if it were true, what that makes different from today. The absurd statement is not a proposal; it is a stepping stone you stand on only long enough to reach somewhere you could not have walked to directly. It works because judgment and movement are opposite mental motions, and every honest constraint you carry is also a wall you have stopped seeing.

Source: Edward de Bono, Po: Beyond Yes and No (1972) and Serious Creativity (1992).

Workflow

Step 1: Confirm the target

A valid target is a concrete creative problem where the usual answers have gone stale: a design that keeps converging on the same shape, a constraint everyone treats as physics, a process nobody questions anymore. Good phrasings: "reinvent how we onboard new users", "our pricing page always ends up looking identical to competitors", "the approval step feels untouchable — challenge it". If the target is unclear, ask one focused question — "What's the problem, and which constraint or convention feels most fixed?"

Refuse requests to perform analytical work — debugging, reviewing code, implementing a change — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Surface the rules

List 4–6 operating rules or constraints that everyone treats as fixed about the target. Write them as flat declaratives, not questions — the things so obvious nobody says them out loud. These are the walls. Each one is a candidate to break, invert, or exaggerate in the next step. If you cannot name at least four, the target is probably too vague; go back to Step 1.

Step 3: Generate 4–6 provocations

Draw across the five classical operations. Prefix each with Po: and keep it to one line. A good Po is one you could not defend as a real suggestion — if it sounds reasonable, it is not a provocation yet, push it further.

  • Escape — drop a rule entirely. Take a rule from Step 2 and state its absence as fact. Po: the checkout has no prices.
  • Reversal — invert a relationship. Flip who does what to whom, or which direction something flows. Po: the user reviews the software's work.
  • Exaggeration — push a quantity to an impossible extreme (up or down to zero). Po: onboarding takes three seconds.
  • Distortion — scramble the normal sequence or swap the roles in it. Po: you pay the invoice before the work is scoped.
  • Wishful thinking — state a fantasy as accomplished fact. Po: the page reads the visitor's mind.

Cover at least three of the five operations across the batch. Do not run more than eight in one batch.

Step 4: Movement, per provocation

Never evaluate the provocation itself — do not ask whether it is good, safe, or possible. That is judgment, the wrong motion. Instead extract movement three ways:

  • (a) The principle — what general idea is hiding inside the absurd statement?
  • (b) Moment-to-moment — if it were literally true, what would happen, step by step, in the first minute?
  • (c) The difference — what is concretely different from how things work today?

Then shape any live thread into a real idea. Not every provocation reaches one — that is expected and honest (see Honesty mechanics). Show the movement work, not just the idea it produced.

Step 5: Meta-pattern scan

Scan across the ideas that landed for a structural property that kept recurring — "every provocation that paid off removed a step rather than adding one", "the strong ones all shifted work from the user onto the system", "three of them turned a cost into a signal". State the structural insight explicitly. This cross-provocation observation is often where the deepest result lives, and it also explains why the abandoned ones failed.

Step 6: Honest ranking

Pick the 2–4 sharpest directions and rank them. Say which feel weak, and why. Then offer next moves and stop: run more provocations, go deeper on one direction, switch to a different technique, or stop here. Never push the user to commit — divergence is your job; the decision is theirs.

Honesty mechanics

A provocation that yields no movement after two honest attempts is abandoned visibly. Show it, for example:

Po: customers pay us to leave — no movement found. Moving on.

Roughly 1 in 3 provocations will not pay off. A batch where every single Po produces a clean idea is a tell that the movement was faked — the operator judged the provocations into safe suggestions instead of moving off them. Show the failures; they are what proves the rest are real.

When the batch itself fails. If almost nothing moves, the problem is upstream of the provocations. Do not write more of them. Name the diagnosis, suggest the technique that fits it as the user's next move, and stop there — do not run it yourself:

  • Step 2 could not produce four rules everyone treats as fixed → the target is too vague, or it is not actually fenced. Suggest random-stimulus, which needs no constraint to push against.
  • The rules are real but every Po lands back on the same idea → you may be solving the wrong problem. Suggest concept-fan, which climbs to the concept the target serves.

What NOT to do

  • Don't defend or attack the provocation. It is not a proposal. Arguing "that would never work" or "actually that's reasonable" both miss the point — extract movement instead.
  • Don't generate polite, plausible provocations. If a Po could pass as a genuine suggestion, it is not a provocation. Push it until it is clearly absurd.
  • Don't skip the movement structure. Jumping straight from the Po to a finished idea hides the reasoning and usually smuggles in an idea you already had.
  • Don't run more than 8 provocations per batch. Quality drops and the movement work gets rushed.

References

Random Stimulus

What this technique does

Pick a random thing from outside the problem space — a tree, a glacier, a kettle. List its properties. Force a connection to the target. See what falls out.

The first stimuli you draw are usually trash. The third or fourth is where real ideas appear — which is why you draw a batch and not a single object. The technique works because staying inside the problem space routes you through familiar associations; an external stimulus breaks the routing and forces a fresh trajectory through the same target. The stimulus has a structural property — cyclical, layered, swarming, ephemeral, branching — that the target could have but doesn't yet. That mismatch is where new designs hide.

Source: Edward de Bono, Lateral Thinking: Creativity Step by Step (1970), specifically the Random Word / Random Object method.

Workflow

Step 1: Confirm the target

A valid target is a concrete creative problem: names for a feature, ideas for a product, a novel onboarding flow, how to position a brand. If the target is unclear, ask one focused question — "What's the creative problem, and are there hard constraints?" Default batch size is 8–12 stimuli.

Refuse requests to perform analytical work — debugging, reviewing code, implementing a change — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Pull stimuli

Draw 8–12 stimuli from references/stimulus-pools.md. Three minimums, all checkable against the batch you drew — Step 3 requires you to label each stimulus with its pool, which is what lets a reader check them:

  • At least five distinct categories. Not "mixed" as a feeling — count them.
  • At least two concrete physical objects and at least one abstraction. Judge this per stimulus, not per pool: hourglass and circadian rhythm both live in Time & Cycles, but one is an object you could hold and the other is a rhythm you cannot. Mark each stimulus [concrete] or [abstract] beside its pool label so the count is visible. Pure-abstract batches feel intellectualized; pure-concrete batches feel mundane.
  • No two stimuli from the same category adjacent in the batch order.

If the user offers a triggering metaphor ("look out the window", "what's in my kitchen"), bias toward that pool but always include 2–3 unrelated stimuli to break the cluster. A fully on-theme batch defeats the purpose of randomness.

Track which stimuli have been used this session. On a second batch, draw fresh ones.

Step 3: For each stimulus, generate and show the chain

The chain is the artifact, not just the resulting idea. Show every link: the stimulus, its properties, the force-fit jump, the idea.

Open with a one-paragraph framing of why the technique works (first invocation only). Use a visual marker (emoji) per stimulus. Show the property list and the → force-fit arrow inline.

Label each stimulus with its pool and its kind — 🗼 The lighthouse beam — Vehicles & Transit [concrete]. The label is what makes Step 2's minimums checkable: a reader counts the distinct categories, spots two adjacent draws from the same pool, and tallies concrete against abstract. Unlabelled chains make the rule unfalsifiable, which is the same failure as "it feels strained."

Per-stimulus length varies by quality of result. A weak stimulus gets two sentences and abandonment. A strong one gets two to three paragraphs, developed into a concrete direction with precedent where it exists.

Step 4: Embrace abandonment

Roughly 1 in 4 stimuli will not pay off. Show this explicitly, for example: "🪡 The threading of a needle — every fit restated the target. Moving on."

Abandonment is a feature. It signals the method is genuine rather than retrofitted, and it reminds the user that quantity is what creates quality here. Forcing every stimulus to produce a good idea poisons the output.

The redundancy test. Before keeping a force-fit, ask: could I have reached this idea from the target alone, without the stimulus? If yes, the stimulus did no work — abandon it, however pretty the image. This is the test; "it feels strained" is not, because the operator who wants to look clever never feels strained.

The seductive failure is a stimulus that restates the target as a nicer picture of itself. A river delta laid over a churn dashboard yields "commits flow and deposit sediment" — vivid, and exactly what you already knew. Abandon it.

Hard rule: apply the redundancy test to every attempt, and abandon the stimulus the moment two successive attempts both fail it. A further attempt is worth making only to confirm the stimulus is dead, and it must be shown as such — "→ Third attempt: nothing new" — never as hope. Patience belongs to the batch, not to any one object.

Step 5: Find the meta-pattern

After the batch, scan across the ideas that landed for a structural property that kept recurring — "all the strong hits had time or slowness as a feature", "three of the strongest cast the user as a defender, not a buyer", "most of these turned out to be community products, not tools".

Then scan the abandonments the same way. They usually share a reason, and that reason is itself a finding: if every dead stimulus died by restating the target, the target has an axis it is missing. Say what the abandonments had in common, not just that they happened. A good meta-pattern explains the failures as well as the hits.

This cross-stimulus observation is often where the deepest insight lives. State it explicitly. Name it mid-batch if it emerges before the end.

Step 6: Honest ranking, no closure pressure

Pick the 3–5 sharpest directions. Say which feel weak, and why. Do not push the user to commit.

End with an explicit offer: pull more stimuli, go deeper on one direction, switch technique, or stop. The user controls when the technique ends.

Honesty mechanics

Abandonment rule: two force-fit attempts, then the redundancy test from Step 4. A batch where every stimulus produces a viable idea is a tell that the output is fabricated — expect 2–3 abandonments per batch of 8–12.

When the batch itself fails. If more than half the stimuli die, do not draw more — that is the move that just failed. A target that nothing external will attach to is over-constrained or wrongly framed, and that is a diagnosis, not bad luck. Name the diagnosis, suggest the technique that fits it as the user's next move, and stop there. Do not run it yourself:

  • The target is phrased as a solution rather than a problem, or you suspect you are answering the wrong question → suggest concept-fan, which climbs to the concept the solution serves.
  • The target is fenced by a constraint so fixed that every stimulus bounces off it → suggest provocation, which breaks the constraint on purpose.

Meta-pattern step: never skip Step 5. The individual ideas matter less than the structural insight that emerges across them — and the abandonments are part of that scan, not excluded from it.

What NOT to do

  • Don't sanitize weird ideas. The unexpectedness is the value. If a force-fit produces something edgy or impractical, ship it as a direction; don't soften it.
  • Don't force every stimulus to produce a viable idea. Abandonment is honest output.
  • Don't keep a force-fit that restates the target. A vivid image is not a new idea. If you could have reached it without the stimulus, the stimulus did nothing — abandon it.
  • Don't answer a failed batch by drawing more stimuli. That is the move that already failed. Diagnose the target and suggest the technique that fits — as a next move for the user, not one you run yourself.
  • Don't repeat stimuli across batches in the same session.
  • Don't skip the meta-pattern step. It is where the gold is, and it covers the abandonments too.
  • Don't push the user toward a decision. The technique is divergent; convergence belongs to the user.
  • Don't run more than ~15 stimuli per batch. Returns diminish and quality suffers.

References

SCAMPER

What this technique does

Take one existing thing — a feature, a product, a workflow — and push it through seven transformation lenses in fixed order. Each lens asks a different question: what could you swap out, what could you fuse it with, what could you borrow, what could you exaggerate or shrink, what else it could do, what could you cut, what could you flip. The value is coverage: the checklist forces you past the two or three variations you would have thought of unaided and into the ones you would have skipped. It is a divergent tool for an idea that already exists, not a way to invent one from nothing.

Source: Bob Eberle, SCAMPER: Games for Imagination Development (1971), building on Alex Osborn's checklist of idea-spurring questions.

Workflow

Step 1: Confirm the target

A valid target is an existing idea, artifact, or process: a shipped feature, a signup flow, a pricing model, a ritual your team runs. SCAMPER transforms something that already works; it cannot operate on a blank page. If the user brings no starting idea — "help me think of a product" — refuse and point them to a generative technique (a random-stimulus or free-association method) that manufactures ideas from nothing. This one needs raw material.

If the target is unclear, ask one focused question — "What's the existing idea, and what part of it is fixed versus open to change?" — then proceed.

Refuse requests to perform analytical work — "debug this", "review this code", "implement this change" — and suggest an analytical approach instead. But redesigning or reinventing such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Run all seven operations in order

Work the lenses in sequence — Substitute, Combine, Adapt, Modify/Magnify, Put to other use, Eliminate, Reverse/Rearrange. For each one, pull 3-4 pointed questions from references/question-bank.md and answer only the ones that actually bite against this target. Ignore the rest; the bank is a menu, not a form.

Zero hits on an operation is normal and expected. When a lens yields nothing real, mark it empty and move on — do not manufacture a variant to fill the slot.

Step 3: Collect the hits into concrete variants

Gather the questions that landed into named variants. Each variant states three things plainly: what changes, what it costs, and what it risks. A variant with no cost and no risk is usually a variant you have not thought through.

Step 4: Meta-pattern scan

Look back across the run: which operations kept producing hits, and which came up dry? Concentrated production is a signal. If Substitute and Eliminate both kept biting, the idea is probably carrying weight it does not need or resting on a swappable assumption — that is where it is soft. Name the pattern explicitly; it is often more useful than any single variant.

Step 5: Honest ranking with next-move offers

Rank the variants by real promise, say which ones are weak and why, and stop there. Offer next moves — go deeper on one variant, rerun a single operation harder, switch to a convergent technique to narrow, or stop — and let the user pick. Never push the user to commit.

Honesty mechanics

Operations with no bite are shown empty, not padded. Write the emptiness plainly, for example:

Eliminate: nothing left to remove — this idea is already minimal. Moving on.

A SCAMPER run where all seven operations "work" is a tell that the output is manufactured. On a real target, expect 3-5 of the seven to bite and the rest to come up empty. Showing the empty ones is what proves the run was genuine rather than retrofitted.

What NOT to do

  • Don't answer every question in the bank. Pick the ones with teeth against this specific target; skip the rest without comment.
  • Don't disguise the same variant under two operations. If "let users trigger it manually" shows up under both Substitute and Reverse, it is one idea, not two. Count it once.
  • Don't SCAMPER a vague target. Sharpen it first. Transforming a fuzzy idea produces seven fuzzy variants.
  • Don't pad empty operations. An honestly empty lens is a result, not a gap to fill.
  • Don't push the user toward a decision. The technique is divergent; convergence belongs to the user.

References

Six Thinking Hats

What this technique does

Take one decision and run it through six deliberately separated perspectives, one at a time. Each pass wears a single "hat": facts, feelings, risks, benefits, alternatives, then synthesis. The power is in the separation — a group that argues all six dimensions at once collapses into whoever talks loudest, but a group that examines facts only, then feelings only, surfaces things the argument would have buried. It converts a tug-of-war into six clean passes over the same ground.

Based on Edward de Bono's Six Thinking Hats® method (Six Thinking Hats, 1985). Six Thinking Hats is a registered trademark of the de Bono Group; this skill is an independent educational implementation.

Workflow

Step 1: Confirm the target

A valid target is a decision — something with an option to accept, reject, or modify. "Should we ship X in v1?", "Do we adopt this dependency?", "Which of these two rollout plans?" all qualify. If the request is open-ended ideation with no decision to weigh ("what could we build next?"), this is the wrong technique — point the user to a generative technique such as ../random-stimulus/SKILL.md instead. If the target is unclear, ask one focused question: "What's the specific decision, and what are the options on the table?"

Refuse requests to perform analytical work — "debug this", "review this code", "implement this change" — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Run the six passes in fixed order

Run all six, each under its own clear heading, never blending. If material for one hat surfaces while wearing another, park it and raise it when its hat comes up.

  • White — facts only. State only what is verifiable. Name the missing data explicitly rather than guessing at it. No opinions, no interpretation.
  • Red — gut reactions. One line each, no justification permitted. The instant "this feels wrong" or "I'd be relieved" — recorded, not defended. Justifying a feeling turns it into a Black or Yellow point; don't.
  • Black — risks and failure modes. Each risk tied to a mechanism — how it actually goes wrong — not a vibe. "This could fail" is not a Black-hat point; "this fails if traffic doubles because the queue is unbounded" is.
  • Yellow — benefits and best-case. Each benefit tied to a mechanism too. Not "this would be great" but "this cuts onboarding time because the config step disappears."
  • Green — alternatives and modifications. Minimum three. At least one must abandon the premise of the decision entirely rather than tweak it.
  • Blue — synthesis. What did the hats disagree about? What piece of information would change the answer? End with a recommendation carrying a stated confidence level.

Step 3: Offer next moves

Offer, don't push: re-run a single hat deeper, take one of the Green alternatives through all six hats, switch to another technique, or stop here. Never pressure the user to commit to the recommendation.

Honesty mechanics

The Red hat must bite. It must contain at least one feeling that contradicts the emerging conclusion — the discomfort with a decision that otherwise looks clean, or the reluctance to reject something that fails on paper. If no such feeling genuinely surfaced, say so explicitly rather than manufacturing one: Red hat is suspiciously aligned — flagging possible motivated reasoning. A Red hat where every feeling agrees with the answer is a tell.

The Blue hat must not paper over the split. Name the strongest unresolved tension in plain terms — the one thing that, if it broke the other way, flips the recommendation. Synthesis is not the same as consensus; a real disagreement between the hats is more useful reported than smoothed.

What NOT to do

  • Don't blend the hats. A risk that occurs to you during Yellow gets deferred to Black, explicitly ("noting a risk here — holding it for Black"). Mixing dimensions is the exact failure the technique exists to prevent.
  • Don't let Blue introduce new material. Blue synthesizes what the other five hats produced. A fresh fact or risk appearing for the first time in Blue means an earlier hat was run lazily — go back.
  • Don't run this on a problem with no decision in it. No option to accept or reject means no target. Redirect to a generative technique.
  • Don't skip Red because "feelings aren't data." Surfacing the feelings is the hat's job. Unspoken reluctance sinks more decisions than any spreadsheet; the Red hat drags it into the open where it can be examined.

References

Worst Possible Idea

What this technique does

Ask for the worst solution to the problem, not the best. Design solutions that would reliably make things terrible, then dissect each one to find the exact mechanism that makes it bad. Invert that mechanism, and you have a feature. The move works because "what's the best design?" routes through everyone's inhibitions and lands on the safe, obvious answer, whereas "how would we guarantee failure?" removes the fear of being wrong and lets people say things out loud — and every named failure mode is a design principle wearing its opposite.

Source: reverse brainstorming, attributed to Hotpoint's product development practice in the 1950s, and standard in the d.school/IDEO facilitation toolkit as "Worst Possible Idea."

Workflow

Step 1: Confirm the target

A valid target is a concrete creative problem stated as something to design or reinvent: an onboarding flow, a pricing page, a landing page, a naming direction, a ritual the team runs. If the target is unclear, ask one focused question — "What are we designing, and what would 'good' look like?"

Refuse requests to perform analytical work — debugging, reviewing code, implementing a change — and suggest an analytical approach instead. Redesigning or ideating about such a process is a valid creative target: "reinvent our code-review ritual" is in scope; "review this PR" is not.

Step 2: Generate genuinely terrible solutions

Produce 5–8 solutions that would make the problem worse. The bar is high: each one must be plausible enough that someone, somewhere, has actually shipped it. Cartoon evil ("delete the user's files!") is too easy and teaches nothing. The useful terrible ideas are the ones a real team rationalized its way into — the ones that sound almost defensible in a meeting.

Show them plainly. Do not soften them, and do not pre-apologize for them.

Step 3: Isolate the mechanism of badness

For each bad idea, state in one sentence why it is bad — the mechanism, not the symptom. Not "it's annoying" but the structural reason it fails.

Example: "it's bad because it makes the user prove value to the product, not the reverse."

The mechanism is the whole technique. A bad idea with no articulated mechanism is just a bad idea.

Step 4: Invert the mechanism, not the idea

Flip the mechanism into its opposite. This is not "don't do the bad thing" — that only gets you back to neutral. Inverting the mechanism produces a positive design principle.

Bad idea's mechanism: "it makes the user prove value to the product." Inversion: "make the product prove value before asking anything of the user."

Inverting the surface ("so, don't make users prove value") is the common failure. Invert the underlying force.

Step 5: Develop the inversions

Take the 2–4 strongest inversions and push each into a concrete direction — an actual feature, layout, flow, or line of copy. An inverted mechanism is a principle; a direction is something you could build on Monday.

Step 6: Meta-pattern scan

The mechanisms of badness cluster. Read them side by side and name the cluster out loud: it is a map of what this thing must never do. Often three or four separate terrible ideas turn out to be the same underlying sin in different costumes. State that sin explicitly — it is usually the sharpest output of the whole session.

Step 7: Honest ranking, no closure pressure

Rank the surviving directions. Say which are strong, which are thin, and why. Offer next moves — develop one further, generate a fresh batch of terrible ideas, switch technique, or stop. Never push the user to commit.

Honesty mechanics

The secretly-clever disqualification. Sometimes a "worst idea" turns out to be quietly good — a real business model or a legitimate feature in disguise. When that happens, the idea has failed as a worst idea and must be disqualified and replaced with a genuinely terrible one. Say so out loud:

"charge per bug report" is actually a support-tier pricing model in disguise — too good, replacing.

This keeps the batch honest. If nothing in the batch makes you wince, the batch is fake.

Dead mechanisms. Not every mechanism inverts into something useful. Some flip into the blandly obvious, or into a principle you already follow, or into nothing at all. Show at least one dead — invert it, look at the result, and declare it dead rather than dressing it up. A batch where every mechanism yields treasure is a tell that the output was reverse-engineered from the answers.

When the batch itself fails. If most mechanisms invert into principles you already follow, the technique has told you something real: this thing is not failing for lack of imagination, and more terrible ideas will not help. Name the diagnosis, suggest the technique that fits it as the user's next move, and stop there — do not run it yourself:

  • The inversions are all things you already do → the design is sound and the question is elsewhere. Suggest concept-fan to check you are solving the right problem.
  • You cannot generate a terrible idea that anyone would actually ship → the target is too small or too abstract to have failure modes. Suggest random-stimulus for generative range.

What NOT to do

  • Don't sanitize the terrible ideas. The wince is the signal. If a bad idea is genuinely uncomfortable, keep it uncomfortable — the softened version teaches nothing.
  • Don't invert the surface. "Don't do X" is not an inversion of X; it is the absence of X. Invert the mechanism underneath X into a positive force.
  • Don't skip the mechanism step. Jumping straight from bad idea to good idea skips the only part that does work. The mechanism IS the technique; without it you are just guessing at features.
  • Don't force every mechanism to pay off. Show the dead ones dead.
  • Don't push the user toward a decision. The technique is divergent; convergence belongs to the user.

References

Sponsors

Details

Marketplace
danium/lateral-thinking
Source
.
Category
Community