Finishing a Development Branch
obra/superpowers
Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.
Forced Analogy / Structural Transplant — map the problem onto a structurally similar system from a distant domain (immune system, air-traffic control, restaurant kitchen, jazz ensemble) and transfer…
$ npx skills add danium/lateral-thinking --skill analogy -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install danium/lateral-thinking analogy --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/danium/lateral-thinking.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/analogy .claude/skills/analogy && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "analogy" agent skill from https://github.com/danium/lateral-thinking/tree/main/skills/analogy into .claude/skills/analogy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "analogy", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/danium/lateral-thinking/tree/main/skills/analogyType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add danium/lateral-thinking --skill analogy -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install danium/lateral-thinking analogy --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/danium/lateral-thinking.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/analogy .agents/skills/analogy && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "analogy" agent skill from https://github.com/danium/lateral-thinking/tree/main/skills/analogy into .agents/skills/analogy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "analogy", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add danium/lateral-thinking --skill analogy -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install danium/lateral-thinking analogy --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/danium/lateral-thinking.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/analogy .cursor/skills/analogy && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "analogy" agent skill from https://github.com/danium/lateral-thinking/tree/main/skills/analogy into .cursor/skills/analogy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "analogy", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/danium/lateral-thinking.git --path skills/analogy--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add danium/lateral-thinking --skill analogy -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install danium/lateral-thinking analogy --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/danium/lateral-thinking.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/analogy .gemini/skills/analogy && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "analogy" agent skill from https://github.com/danium/lateral-thinking/tree/main/skills/analogy into .gemini/skills/analogy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "analogy", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install danium/lateral-thinking analogyInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add danium/lateral-thinking --skill analogy -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/danium/lateral-thinking.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/analogy .github/skills/analogy && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "analogy" agent skill from https://github.com/danium/lateral-thinking/tree/main/skills/analogy into .github/skills/analogy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "analogy", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add danium/lateral-thinking --skill analogy -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install danium/lateral-thinking analogy --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/danium/lateral-thinking.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/analogy .opencode/skills/analogy && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "analogy" agent skill from https://github.com/danium/lateral-thinking/tree/main/skills/analogy into .opencode/skills/analogy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "analogy", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
analogyForced Analogy / Structural Transplant — map the problem onto a structurally similar system from a distant domain (immune system, air-traffic control, restaurant kitchen, jazz ensemble) and transfer…
Analogy is an agent skill from danium/lateral-thinking. Forced Analogy / Structural Transplant — map the problem onto a structurally similar system from a distant domain (immune system, air-traffic control, restaurant kitchen, jazz ensemble) and transfer its mechanisms back. Use when a solution works but feels derivative, when the industry playbook is exhausted, or when a system in nature or another trade already solves this shape of problem. Triggers include "analogy", "forced analogy", "how would a hospital/kitchen/airport handle this", "transplant from another…
Its SKILL.md is about 1.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/domain-pool.md` and `references/worked-example.md`).
It sits in Development. The repository describes itself as: Lateral thinking skills for AI agents - 8 techniques + a router. de Bono for your coding agent. The licence is MIT.
6 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit bde713d. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md.
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Analogy loads about 1.6k tokens when it runs, and up to ~5.5k if it reads all its reference files. Until then it costs about 162 tokens; SKILL.md has 868 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from danium/lateral-thinking at commit bde713d, republished under its MIT licence (© danium). 868 words, ~1,579 tokens.
.claude/skills/analogy/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.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.
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.
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.
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.
For each domain, do two things in order:
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.
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.
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:
concept-fan, which climbs until the real problem appears.random-stimulus, which needs no structural rhyme to make a jump.references/domain-pool.md — structurally rich source domains to draw from, with the transferable property of eachreferences/worked-example.md — a real session showing the full shape, one genuine abandonment included© danium, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 2 other files (references) in skills/analogy of danium/lateral-thinking.
Open the folder on GitHubat commit bde713d
Analogy next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Analogy this skilldanium/lateral-thinking | 318 | — | ~1.6k | Automated safety check: Pass | MIT | |
| Finishing a Development Branchobra/superpowers | 296k | 5 repos | ~1.9k | Automated safety check: Pass | MIT | |
| Typescript Advanced Typesrolling-scopes/rsschool-app | 10k | 24 repos | ~4.2k | Automated safety check: Pass | MPL-2.0 | |
| PR Babysitteropeninterpreter/openinterpreter | 69k | 3 repos | ~4.2k | Automated safety check: Pass | Apache-2.0 | |
| Code Review ChecklistshareAI-lab/learn-claude-code | 78k | 5 repos | ~1.1k | Automated safety check: Pass | MIT | |
| Greplooponyx-dot-app/onyx | 32k | 4 repos | ~3.3k | Automated safety check: Pass | MIT |
obra/superpowers
Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.
rolling-scopes/rsschool-app
Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.
openinterpreter/openinterpreter
Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.
shareAI-lab/learn-claude-code
Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.
onyx-dot-app/onyx
Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.
akash-network/node
Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.
danium/lateral-thinking
Edward de Bono's Concept Fan — climb from the current solution to the concept it serves by asking "what is this a way of doing?", then fan out alternative concepts and concrete implementations for…
danium/lateral-thinking
Assumption Inversion — list the assumptions behind the current approach and flip each one, then ask where the flipped version could actually be true.
danium/lateral-thinking
Edward de Bono's Provocation (Po) technique — state something deliberately wrong or absurd about the problem, then extract useful "movement" from it instead of judging it.
danium/lateral-thinking
Edward de Bono's Random Stimulus technique — force-fit a random unrelated object, place, or phenomenon onto a creative target to break familiar association patterns.
danium/lateral-thinking
SCAMPER (Bob Eberle) — run one existing idea, product, or process through seven systematic transformations - Substitute, Combine, Adapt, Modify/Magnify, Put to other use, Eliminate, Reverse/Rearrange.
danium/lateral-thinking
Parallel thinking with six enforced perspectives, based on Edward de Bono's Six Thinking Hats® method - examine one decision through sequential passes for facts, feelings, risks, benefits…
Categories
Forced Analogy / Structural Transplant — map the problem onto a structurally similar system from a distant domain (immune system, air-traffic control, restaurant kitchen, jazz ensemble) and transfer…. Analogy is an agent skill from danium/lateral-thinking. Forced Analogy / Structural Transplant — map the problem onto a structurally similar system from a distant domain (immune system, air-traffic control, restaurant kitchen, jazz ensemble) and transfer its mechanisms back.
Analogy fits situations like: A solution works but feels derivative; the industry playbook is exhausted; A system in nature; another trade already solves this shape of problem.
Run `npx skills add danium/lateral-thinking --skill analogy -a claude-code`. Or copy the skill folder (skills/analogy in danium/lateral-thinking) into .claude/skills/analogy in your project. Claude Code loads it when a task matches its description.
Run `npx skills add danium/lateral-thinking --skill analogy -a codex`. Or copy the skill folder (skills/analogy in danium/lateral-thinking) into .agents/skills/analogy in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add danium/lateral-thinking --skill analogy -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/analogy, .gemini/skills/analogy, .github/skills/analogy and .opencode/skills/analogy in your project.
SKILL.md names no scripts, command-line tools or credentials: Analogy is instructions for the agent only.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Analogy is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 1.6k tokens (SKILL.md is roughly 6.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.9k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Analogy: Finishing a Development Branch (obra/superpowers, 296k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars), PR Babysitter (openinterpreter/openinterpreter, 69k stars) and Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
danium (a GitHub user) maintains it in danium/lateral-thinking, which has 318 GitHub stars. The repository holds 10 skills in this directory. The repository was last updated on September 13, 2026.
Source: danium/lateral-thinking on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.