Brainstorming Before Building
jnMetaCode/superpowers-zh
Turns a rough idea into an approved design before any code is written, sorting the request into spike, bounded or architectural and enforcing an approval gate.
Runs a 100-question self-interrogation of a design, plan, strategy or idea, each question building on the last, to expose weaknesses before you commit.
Install Deep Discovery
$ npx skills add forsonny/deep-discovery --skill deep-discovery -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install forsonny/deep-discovery deep-discovery --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/forsonny/deep-discovery.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/deep-discovery .claude/skills/deep-discovery && 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 "deep-discovery" agent skill from https://github.com/forsonny/deep-discovery/tree/main/skills/deep-discovery into .claude/skills/deep-discovery/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deep-discovery", 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/forsonny/deep-discovery/tree/main/skills/deep-discoveryType 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 forsonny/deep-discovery --skill deep-discovery -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install forsonny/deep-discovery deep-discovery --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/forsonny/deep-discovery.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/deep-discovery .agents/skills/deep-discovery && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "deep-discovery" agent skill from https://github.com/forsonny/deep-discovery/tree/main/skills/deep-discovery into .agents/skills/deep-discovery/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deep-discovery", 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 forsonny/deep-discovery --skill deep-discovery -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install forsonny/deep-discovery deep-discovery --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/forsonny/deep-discovery.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/deep-discovery .cursor/skills/deep-discovery && 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 "deep-discovery" agent skill from https://github.com/forsonny/deep-discovery/tree/main/skills/deep-discovery into .cursor/skills/deep-discovery/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deep-discovery", 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/forsonny/deep-discovery.git --path skills/deep-discovery--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 forsonny/deep-discovery --skill deep-discovery -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install forsonny/deep-discovery deep-discovery --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/forsonny/deep-discovery.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/deep-discovery .gemini/skills/deep-discovery && 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 "deep-discovery" agent skill from https://github.com/forsonny/deep-discovery/tree/main/skills/deep-discovery into .gemini/skills/deep-discovery/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deep-discovery", 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 forsonny/deep-discovery deep-discoveryInstalls 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 forsonny/deep-discovery --skill deep-discovery -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/forsonny/deep-discovery.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/deep-discovery .github/skills/deep-discovery && 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 "deep-discovery" agent skill from https://github.com/forsonny/deep-discovery/tree/main/skills/deep-discovery into .github/skills/deep-discovery/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deep-discovery", 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 forsonny/deep-discovery --skill deep-discovery -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install forsonny/deep-discovery deep-discovery --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/forsonny/deep-discovery.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/deep-discovery .opencode/skills/deep-discovery && 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 "deep-discovery" agent skill from https://github.com/forsonny/deep-discovery/tree/main/skills/deep-discovery into .opencode/skills/deep-discovery/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deep-discovery", 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.
Facts
- Skill name
deep-discovery- GitHub stars
- 103
- Token cost
- ~1.7k tokens
- SKILL.md length
- 699 words
- Files
- 8 (incl. references)
- Skills in repo
- 1
- Repo updated
- First seen
- Licence
- MIT
At a glance
Runs a 100-question self-interrogation of a design, plan, strategy or idea, each question building on the last, to expose weaknesses before you commit.
- Works in 4 steps: Identify the topic, available context,… → Choose the mode → Choose the closest domain pattern:… → …
- Stress-testing an architecture or design before committing to it
- SKILL.md covers Preflight, How It Works, Running the Process and Variations, plus 2 more sections
- Calls codex
What it does
The skill turns a topic into a sequential self-dialogue of 100 questions: the agent asks a question, answers it, then asks the next based on what the answer revealed. A preflight step identifies the topic, context and focus, asks at most three clarifying questions if needed, and chooses a mode (evaluating an existing design, exploring from scratch, or comparing two or three options) and a domain pattern such as software architecture, code review, Codex plugin creation, business and product, trading and finance, or general.
Questions move through phases: foundation, mechanics, stress testing, competitive analysis, feasibility, refinement and synthesis. The first question is always about the goal and how to reach it. Rules require each question to build on the previous answer, to challenge assumptions, to stay concrete with numbers and scenarios, and to spend several questions on any critical flaw an answer reveals. Domain reference files supply extra prompts, and once enough context exists the run proceeds without further input unless you ask to take part.
When your agent uses it
- Stress-testing an architecture or design before committing to it
- Vetting a business or product idea for weaknesses
- Choosing between two or three options with a structured comparison
- Reviewing a Codex plugin or skill plan before building it
Example prompts
- “Run a deep discovery on my plan to move our billing to an event-driven architecture.”
- “Poke holes in this startup idea with a 100-question interrogation.”
- “Compare these three database options using deep discovery.”
Workflow steps
4 steps, taken from the first numbered list in SKILL.md.
- Identify the topic, available context, focus, and starting point. If any of
- Choose the mode
- Choose the closest domain pattern: software architecture, code review,
- After enough context is available, run the process without further human
What it can do on your machine
Read from SKILL.md and the folder at commit ad261d3. It shows what the files ask for, not the result of running them.
Tool permissions
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.
Runs code
Shell commands in SKILL.md call:
codex
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Deep Discovery loads about 1.7k tokens when it runs, and up to ~6.9k if it reads all its reference files. Until then it costs about 95 tokens; SKILL.md has 699 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.
Safety
Auto-check passed
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.
SKILL.md
The full file from forsonny/deep-discovery at commit ad261d3, republished under its MIT licence (© forsonny). 699 words, ~1,730 tokens.
Download SKILL.mdSave it as
.claude/skills/deep-discovery/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.- name
- deep-discovery
- description
- Use when the user asks for deep discovery, 100-question brainstorming, idea interrogation, architecture stress testing, strategy vetting, weakness finding, hole-poking, exhaustive exploration, planning or auditing Codex plugins or skills, or pre-commitment review of a design, plan, strategy, architecture, product, business idea, trading system, or problem space.
Deep Discovery
A structured self-interrogation framework that exhaustively explores a topic through 100 sequential questions, each building on the previous answer. Designed to be used in Codex as a skill for rigorous, sequential exploration before committing to a design or decision.
Preflight
- Identify the topic, available context, focus, and starting point. If any of those are too ambiguous to run a useful interrogation, ask at most three clarifying questions before starting.
- Choose the mode:
- Evaluation: an existing design, architecture, strategy, or plan exists.
- Exploration: the user is starting from scratch.
- Comparison: the user is choosing between two or three options.
- Choose the closest domain pattern: software architecture, code review,
Codex plugin/skill creation, business/product, trading/financial, or general.
Use
references/question-patterns.mdas the index, then read only the relevant reference file when domain-specific prompts would improve the run. - After enough context is available, run the process without further human input unless the user explicitly asks to participate.
How It Works
The 100-question process is a self-dialogue: ask a question, answer it, then ask the next question based on what the answer revealed. The questions naturally progress through phases:
Question Progression
| Phase | Questions | Focus |
|---|---|---|
| Foundation | Q1-Q10 | Goal, constraints, assumptions, what makes this unique |
| Mechanics | Q11-Q30 | How it works, components, data flow, dependencies |
| Stress Testing | Q31-Q50 | Edge cases, failure modes, what breaks first |
| Competitive Analysis | Q51-Q65 | What exists, what's different, what's the real edge |
| Feasibility | Q66-Q80 | Can this actually be built/done, what are the blockers |
| Refinement | Q81-Q90 | Improvements, optimizations, what was missed |
| Synthesis | Q91-Q100 | Final architecture, honest assessment, actionable output |
Rules for Questions
- Q1 is always: "What is the goal, and how do we get there?"
- Each question MUST build on the previous answer; avoid random jumps.
- Be brutally honest; surface problems instead of hiding them.
- Challenge assumptions with questions like "Is that actually true?"
- Go concrete, not abstract: use specific numbers and scenarios.
- If an answer reveals a critical flaw, spend multiple questions exploring it.
- The final 10 questions must synthesize everything into actionable output.
- Do not abbreviate the run below 100 questions unless the user explicitly asks for a shorter version.
Running the Process
Run the process in the current Codex conversation by default. If the user explicitly asks to delegate the work to a sub-agent, use Codex's available sub-agent mechanism and summarize the returned findings. Do not assume a delegation tool is available, and do not refer to legacy tool names or custom agent manifests from other harnesses.
Show full SKILL.md (281 more words)Show less
Prompt Template
Use this structure for the deep-discovery run:
Topic: [what we're exploring]
Context: [relevant background - what's already been decided, constraints, goals]
Focus: [what specifically to evaluate - architecture? strategy? feasibility?]
Starting point: [any existing design or proposal to interrogate, or "from scratch"]
Mode: [evaluation | exploration | comparison]
Domain pattern: [software architecture | code review | codex plugin/skill creation | business/product | trading/financial | general]
Do a rigorous 100-question self-brainstorm. Each question builds on the last.
Start with "What is the goal, and how do we get there?" and dig progressively
deeper through mechanics, stress testing, competitive analysis, feasibility,
and synthesis.
Be brutally honest. Find every weakness, every edge case, every failure mode.
Also identify what's strong and worth keeping.
At the end, provide:
1. Questions asked: 100
2. Domain pattern used
3. A numbered list of the top 10 critical issues found
4. A numbered list of the top 10 strengths
5. Specific changes recommended, with rationale
6. A revised proposal or architecture if the original needs significant changes
7. The honest bottom line: one paragraph, no sugar-coatingHandling the Output
After completing the run:
- Extract the key findings - summarize the top issues and strengths for the user.
- Present the revised architecture/proposal if one was generated.
- Integrate findings into the current design process.
- Do NOT dump the full 100 Q&A into the conversation unless the user explicitly asks for it; summarize the insights.
Variations
Evaluation Mode
When an existing design/architecture/plan exists, focus the 100 questions on interrogating that specific proposal. Include the full design and focus on finding flaws, edge cases, and missing constraints.
Exploration Mode
When starting from scratch (no existing proposal), the 100 questions should build toward a complete design. The output should be a fully-formed proposal that emerged from the questioning process.
Comparison Mode
When choosing between 2-3 options, run a separate 100-question process for each, then compare the findings. If the user explicitly asks for delegated or parallel work and Codex exposes a suitable mechanism, these runs may be delegated. Synthesize a side-by-side comparison of their top issues, strengths, and revised proposals to present a clear recommendation to the user.
Integration with Other Skills
- Before brainstorming: Run discovery to deeply understand the problem space
- After brainstorming: Run discovery to stress-test the proposed design
- Before writing plans: Run discovery to validate the architecture
- During debugging: Run discovery to exhaustively explore root causes
Additional Resources
Reference Files
references/question-patterns.md- Index of available domain pattern files.references/software-architecture.md- Architecture and system design patterns.references/code-review.md- Patch, branch, and implementation review patterns.references/codex-plugin-creation.md- Codex plugin and skill planning/audit patterns.references/business-product.md- Business strategy and product patterns.references/trading-financial.md- Trading system and financial strategy patterns.references/general-pattern.md- Universal fallback pattern and discovery tips.
© forsonny, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 7 other files (references) in skills/deep-discovery of forsonny/deep-discovery.
- SKILL.md
- references/business-product.md
- references/code-review.md
- references/codex-plugin-creation.md
- references/general-pattern.md
- references/question-patterns.md
- references/software-architecture.md
- references/trading-financial.md
Open the folder on GitHubat commit ad261d3
Compare with similar skills
Deep Discovery 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 |
|---|---|---|---|---|---|---|
| Deep Discovery this skillforsonny/deep-discovery | 103 | — | ~1.7k | Automated safety check: Pass | MIT | |
| Brainstorming Before BuildingjnMetaCode/superpowers-zh | 8.3k | — | ~1.8k | Automated safety check: Pass | MIT | |
| LLM Councilgcpdev/llm-council-skill | 461 | — | ~1k | Automated safety check: Notes | MIT | |
| Let Fate Decidetrailofbits/skills | 7.4k | — | ~2.5k | Automated safety check: Notes | CC-BY-SA-4.0 | |
| CE BrainstormEveryInc/compound-engineering-plugin | 25k | — | ~1.9k | Automated safety check: Pass | MIT | |
| Planmhmzdev/the-holy-quran-app | 889 | — | ~957 | Automated safety check: Pass | MIT |
Similar skills
LLM Council
gcpdev/llm-council-skill
Multi-LLM collaborative brainstorming and planning. An agent skill from gcpdev/llm-council-skill.
- Official
Let Fate Decide
trailofbits/skills
Draws a 12 Houses tarot spread to break ties when a request is vague or casually delegated, then reads the cards to pick the next step.
CE Brainstorm
EveryInc/compound-engineering-plugin
Turns a vague or ambitious feature idea into a requirements-only plan through dialogue with you, sized to the work, before any code is written.
Plan
mhmzdev/the-holy-quran-app
Turn an idea or brainstorm into an actionable execution plan for The Holy Qur'an app with phases, file changes, and machine-checkable success criteria.
Design Review
xwtro0tk1t-cloud/harness
Dispatch an independent challenger agent to adversarially review a spec or implementation plan against the actual codebase.
Related
Categories
Questions about Deep Discovery
What does Deep Discovery do?
Runs a 100-question self-interrogation of a design, plan, strategy or idea, each question building on the last, to expose weaknesses before you commit. The skill turns a topic into a sequential self-dialogue of 100 questions: the agent asks a question, answers it, then asks the next based on what the answer revealed. A preflight step identifies the topic, context and focus, asks at most three clarifying questions if needed, and chooses a mode (evaluating an existing design, exploring from scratch, or comparing two or three options) and a domain pattern such as software architecture, code review, Codex plugin creation, business and product, trading and finance, or general.
When should I use Deep Discovery?
Deep Discovery fits situations like: stress-testing an architecture or design before committing to it; vetting a business or product idea for weaknesses; choosing between two or three options with a structured comparison; reviewing a Codex plugin or skill plan before building it.
How do I install Deep Discovery in Claude Code?
Run `npx skills add forsonny/deep-discovery --skill deep-discovery -a claude-code`. Or copy the skill folder (skills/deep-discovery in forsonny/deep-discovery) into .claude/skills/deep-discovery in your project. Claude Code loads it when a task matches its description.
How do I install Deep Discovery in Codex?
Run `npx skills add forsonny/deep-discovery --skill deep-discovery -a codex`. Or copy the skill folder (skills/deep-discovery in forsonny/deep-discovery) into .agents/skills/deep-discovery in your project. Codex loads it when a task matches its description.
Can I use Deep Discovery in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add forsonny/deep-discovery --skill deep-discovery -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/deep-discovery, .gemini/skills/deep-discovery, .github/skills/deep-discovery and .opencode/skills/deep-discovery in your project.
What does Deep Discovery need to run?
Going by SKILL.md and its folder, Deep Discovery needs the command-line tools its instructions call (codex).
Does Deep Discovery access the network?
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.
Is Deep Discovery safe to install?
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.
What licence does Deep Discovery use?
Deep Discovery is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Deep Discovery use?
About 1.7k tokens (SKILL.md is roughly 6.9k 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 5.2k tokens, read only when the agent opens those files.
What are the alternatives to Deep Discovery?
Skills that share tags, products or a category with Deep Discovery: Brainstorming Before Building (jnMetaCode/superpowers-zh, 8.3k stars), LLM Council (gcpdev/llm-council-skill, 461 stars), Let Fate Decide (trailofbits/skills, 7.4k stars) and CE Brainstorm (EveryInc/compound-engineering-plugin, 25k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Deep Discovery?
forsonny (a GitHub user) maintains it in forsonny/deep-discovery, which has 103 GitHub stars. The repository was last updated on April 27, 2026.
Source: forsonny/deep-discovery on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.