Brainstorming
xpinjection/test-driven-spring-boot
You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior.
Quant-focused research ideation pipeline: scope selection (3 stages) → anchor-first literature grounding → single-core idea generation → iterative refinement → ELO tournament ranking (Final =…
$ npx skills add CamusGIT/EvoQuant --skill research-ideation -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install CamusGIT/EvoQuant research-ideation --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/CamusGIT/EvoQuant.git skills-src && mkdir -p .claude/skills && cp -r skills-src/EvoQuant/skills/research-ideation .claude/skills/research-ideation && 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 "research-ideation" agent skill from https://github.com/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideation into .claude/skills/research-ideation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "research-ideation", 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/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideationType 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 CamusGIT/EvoQuant --skill research-ideation -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install CamusGIT/EvoQuant research-ideation --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/CamusGIT/EvoQuant.git skills-src && mkdir -p .agents/skills && cp -r skills-src/EvoQuant/skills/research-ideation .agents/skills/research-ideation && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "research-ideation" agent skill from https://github.com/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideation into .agents/skills/research-ideation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "research-ideation", 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 CamusGIT/EvoQuant --skill research-ideation -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install CamusGIT/EvoQuant research-ideation --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/CamusGIT/EvoQuant.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/EvoQuant/skills/research-ideation .cursor/skills/research-ideation && 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 "research-ideation" agent skill from https://github.com/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideation into .cursor/skills/research-ideation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "research-ideation", 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/CamusGIT/EvoQuant.git --path EvoQuant/skills/research-ideation--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 CamusGIT/EvoQuant --skill research-ideation -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install CamusGIT/EvoQuant research-ideation --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/CamusGIT/EvoQuant.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/EvoQuant/skills/research-ideation .gemini/skills/research-ideation && 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 "research-ideation" agent skill from https://github.com/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideation into .gemini/skills/research-ideation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "research-ideation", 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 CamusGIT/EvoQuant research-ideationInstalls 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 CamusGIT/EvoQuant --skill research-ideation -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/CamusGIT/EvoQuant.git skills-src && mkdir -p .github/skills && cp -r skills-src/EvoQuant/skills/research-ideation .github/skills/research-ideation && 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 "research-ideation" agent skill from https://github.com/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideation into .github/skills/research-ideation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "research-ideation", 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 CamusGIT/EvoQuant --skill research-ideation -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install CamusGIT/EvoQuant research-ideation --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/CamusGIT/EvoQuant.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/EvoQuant/skills/research-ideation .opencode/skills/research-ideation && 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 "research-ideation" agent skill from https://github.com/CamusGIT/EvoQuant/tree/main/EvoQuant/skills/research-ideation into .opencode/skills/research-ideation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "research-ideation", 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.
research-ideationQuant-focused research ideation pipeline: scope selection (3 stages) → anchor-first literature grounding → single-core idea generation → iterative refinement → ELO tournament ranking (Final =…
Research Ideation is an agent skill from CamusGIT/EvoQuant. Quant-focused research ideation pipeline: scope selection (3 stages) → anchor-first literature grounding → single-core idea generation → iterative refinement → ELO tournament ranking (Final = N+R+C−D) → update evo-memory → user selects direction → expand into manuscript-quality proposal. Optimized for incremental, anchor-first contributions. Use when: user wants to find a quant research direction, brainstorm ideas within a scope stage, evaluate idea novelty, design a novel solution anchored to an existing paper…
Its SKILL.md is about 5.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 15 other files, including reference files and assets (for example `assets/direction-summary-template.md`, `assets/idea-candidate-template.md` and `assets/paper-summary-template.md`).
It sits in Agent Workflows, covering Brainstorming. The repository describes itself as: EvoQuant is a self-evolving AI research agent specialized in quantitative investment research. It runs the full research loop autonomously. The licence is Apache-2.0.
9 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit ac1c4b8. It shows what the files ask for, not the result of running them.
Pre-approves these tools, so the agent can use them without asking each time:
write_fileedit_fileread_filethink_toolexecuteFrom 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.
Research Ideation loads about 5.4k tokens when it runs, and up to ~20k if it reads all its reference files. Until then it costs about 191 tokens; SKILL.md has 2,168 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 CamusGIT/EvoQuant at commit ac1c4b8, republished under its Apache-2.0 licence (© CamusGIT). 2,168 words, ~5,362 tokens.
.claude/skills/research-ideation/SKILL.md (or your agent's skills folder). This skill also uses 13 other files; get the full folder from GitHub.From research goal to ranked ideas and a detailed proposal.
Step 0: Load evo-memory (M_I)
↓
Step 1: Define Scope & Goal
↓
Step 2: Literature Grounding (MUST use local-paper-navigator scripts)
↓
Step 3: Generate Ideas (3 Anchor Papers × Innovator persona)
↓
Step 4: Refine Ideas (3 tracks × N iterations)
↓
Step 5: ELO Tournament → Present Top-3 to User
↓
Step 6: Update evo-memory (IDE)
↓
User Selects
↓
Step 7: Expand into Proposal
↓
Step 8: Validate and IterateNote: This pipeline is optimized for quantitative research where incremental, anchor-first contributions are preferred over architectural redesigns.
local-paper-navigatorresearch-surveypaper-planningBefore any ideation begins, load Ideation Memory (M_I) from prior research cycles:
/memory/ideation-memory.md (refer to evo-memory skill)This step prevents repeating known dead ends and builds on prior successes across research cycles.
The long-term objective of this continual research program is to incrementally improve the quantitative research pipeline through publishable contributions in one of three core stages:
| Stage | Focus |
|---|---|
| Alpha Factor Research | Discover and validate economically meaningful alpha factors grounded in financial theory and empirical evidence |
| Alpha Generation Methodology | Develop more effective methods for discovering, generating, and evolving alpha factors automatically |
| Portfolio Strategy Research | Develop methods that transform one or multiple alpha signals into robust, diversified, and executable investment portfolios under realistic trading constraints. |
Each research session MUST focus on exactly one of the three stages above.
Hard constraints:
Within the chosen scope stage, define a concrete goal. Ask: "What is the smallest improvement that would be publishable in this stage?"
The goal should be narrow enough to complete in one research cycle, yet significant enough to advance the field.
Invoke local-paper-navigator to collect relevant papers from the local papers library. Do NOT skip this step or substitute with general knowledge — ideas must be grounded in real papers.
CRITICAL: All paper discovery in this step MUST use the local-paper-navigator skill and its scripts (local_search, xref_search, similar_papers, snippet_search, etc.). Using WebSearch, WebFetch, or any generic web search tool for finding papers is PROHIBITED. Generic web search returns blog posts, news articles, and low-quality results — only local-paper-navigator provides the local search, cross-reference, and keyword-similarity infrastructure needed for literature grounding.
From the collected papers, construct a challenge-insight tree — a many-to-many mapping between technical challenges and the insights/techniques that address them:
How this drives ideation:
Also generate a condensed literature review synthesis as context for idea generation (for full surveys use research-survey).
See references/literature-tree.md for construction methodology.
Execution rule: Do NOT generate ideas without real paper grounding. The tree must reference actual papers with titles, sources, and findings. Paper search MUST go through local-paper-navigator — never use WebSearch/WebFetch as a shortcut.
Generate 3 initial research ideas, each anchored to a specific paper from the literature grounding (Step 2), grounded in the literature.
| Persona | Focus |
|---|---|
| Innovator | Novelty & creativity — groundbreaking, high-risk/high-reward |
| Pragmatist | Difficulty-aware — realistic scope, minimal resource requirements |
| Critic | Scientific value — advances understanding, rigorous |
Every proposal MUST be anchored to one Anchor Paper — a specific paper from the literature grounding (Step 2) that serves as the primary methodological foundation.
When generating ideas in Step 3, each idea must explicitly state:
Each proposal may introduce at most 1 core innovation point (maximum 2 if tightly related — sharing the same mechanism or directly causally linked).
Innovation should come from refinement of existing methods — improvement, replacement, or extension — not from horizontal concatenation of unrelated methods or modules.
Disallowed: Combining technique A from paper X + technique B from paper Y where A and B address different problems and are not causally linked.
Allowed: Replacing paper X's optimization method with a more effective variant; extending paper X's factor mining pipeline with one additional module; adding one constraint to paper X's portfolio construction.
# Research Idea: [Concise Title]
## Anchor Paper
- **Anchor Paper**: [title + paperId]
- **Inherited components**: [what is kept from the anchor, ≥70%]
- **Innovation delta**: [what is changed/added, ≤30%]
## Core Idea
[One paragraph: the proposal + which research direction it addresses + how the innovation delta extends the anchor]
## Validation Plan
[Concrete experiment outline. Datasets must be chosen from what is actually
available — run `quant-experiment-runtime`'s `discover_data.py --code-repo code-repo`
to list offline data packages, and use `local-paper-navigator` to recover the
paper's tested scope; plan around the intersection, scoped by the paper's test
range + budget + necessity (not the dataset's maximum coverage). Then: baselines,
metrics. See `references/proposal-extension.md` Section 4.]
## Baseline Feasibility
- **Anchor Paper source code**: [available at URL / ❌ no usable code]
- **Implementation mode (preliminary — for difficulty scoring)**: [Adapt / From-Scratch / Hybrid]
- **Difficulty correction**: [base score + adjustment = corrected score, e.g., 3+4=7 if From-Scratch]Run 3 parallel refinement tracks — one per initial idea. Each track uses all 3 personas.
For each track:
For N=3 iterations:
1. Evaluate current best idea (novelty, difficulty, relevance, clarity, anchor-coherence)
2. All 3 personas generate refined versions based on evaluation
3. Pick the best refinement as seed for next iteration
Track champion = best idea across iterationsCritical rule: If evaluation says the approach is a dead-end, the persona MUST pivot — refinement is not restricted to patching.
Rank all track champions through pairwise comparison, then present the top-3 to the user for selection.
| Dimension | What It Measures |
|---|---|
| Novelty | How different from existing published work? (scored 1-10; higher = more novel) |
| Difficulty | Total implementation effort (1-10; higher=harder). Includes baseline reproduction cost — if any baseline requires from-scratch reproduction (no source code), add +3-5. Difficulty measures TOTAL effort, not just the innovation delta. See references/baseline-feasibility.md |
| Relevance | Does this address an important problem aligned with the goal? (scored 1-10; higher = more relevant) |
| Clarity | Is the idea well-defined enough to start immediately? (scored 1-10; higher = clearer) |
Final = Novelty + Relevance + Clarity − Difficulty
references/elo-ranking-guide.md for rubric and formulaAfter the tournament, present the top-3 ideas with both a comparison table and the full refined idea for each. This ensures the user sees the concrete, actionable version of each idea — not just a summary.
## Top-3 Research Ideas (ranked by ELO)
| Rank | Title | Anchor Paper | Innovation Delta | Novelty | Difficulty | Relevance | Clarity | Final | ELO |
|------|-------|-------------|-----------------|---------|------------|-----------|---------|-------|-----|
| 1 | ... | ... | ... | 9 | 3 | 8 | 8 | 22 | 1280 |
| 2 | ... | ... | ... | 7 | 4 | 8 | 7 | 18 | 1240 |
| 3 | ... | ... | ... | 8 | 5 | 9 | 7 | 19 | 1210 |For each of the top-3, present the refined idea using the same structured format as Step 3, plus a refinement summary:
# Refined Idea [Rank]: [Concise Title]
## Anchor Coherence
- Anchor Paper: [title]
- Inherited: [≥70% method description]
- Innovation: [≤30% delta description]
- Coherence check: [Is the innovation tightly integrated with the inherited method?]
## Core Idea
[One paragraph: the refined proposal — this should reflect ALL changes from Step 4 refinement,
not the original Step 3 version]
## Validation Plan
[Concrete experiment outline updated with refinement insights: datasets, baselines, metrics,
key ablations identified during refinement]
## Refinement Summary
[Brief paragraph summarizing what changed from the initial idea and why:
- What was simplified or removed (and why)
- What was added or concretized (and why)
- Which persona drove the most impactful change
- Key risk mitigations added during refinement]This section is mandatory — do NOT skip the full refined ideas or collapse them into the comparison table. The user needs to see the complete, refined version to make an informed selection.
Which idea would you like to develop into a full proposal? (1/2/3, or combine elements)After presenting top-3, trigger Step 6 (evo-memory IDE) before finalizing user selection. The user may:
After the tournament and before the user selects, trigger evo-memory IDE (Idea Direction Evolution):
/direction-summary.mdevo-memory skill with the direction summaryThis ensures future ideation cycles benefit from what was learned in this cycle.
After the user selects an idea, expand it into a manuscript-quality research proposal. This is a two-phase process because different fields require different proposal structures.
Before writing, first generate a proposal template tailored to the user's field:
See assets/proposal-template.md for the complete field-specific section guide and writing instructions.
Fill the generated template following these universal principles:
See references/proposal-extension.md for detailed section guidance.
Run experiments on representative data. If the approach fails, return to Step 3 or Step 4 with updated knowledge. See experiment-craft for systematic debugging.
All paper discovery goes through local-paper-navigator. This skill does not search for papers itself. Using WebSearch, WebFetch, or any generic search tool to find papers is PROHIBITED — these tools cannot access the local papers library. Always use local-paper-navigator and its scripts (local_search, xref_search, similar_papers, snippet_search, etc.) for all paper discovery needs in Steps 2, 3, and 4.
| Step | Requires local-paper-navigator for |
|---|---|
| Step 2 | Collect 30-50 relevant papers for literature tree construction |
| Step 3 | Verify no well-established solution exists for selected problems |
| Step 4 | Cross-domain search for transferable techniques during refinement |
| When | Action | Details |
|---|---|---|
| Step 0 (before ideation) | Read M_I | Load /memory/ideation-memory.md, select top-2 relevant entries, use feasible directions as seeds, avoid fundamental failures |
| Step 6 (after tournament) | Write M_I via IDE | Save top-3 directions with ELO scores as feasible; save dead-end ideas as unsuccessful with failure classification |
| To | When | Key Artifacts |
|---|---|---|
paper-planning | Proposal complete (Step 7) → plan paper structure | /research-proposal.md, /direction-summary.md |
experiment-pipeline | Proposal complete (Step 7) → start experiments | /research-proposal.md, /direction-summary.md |
evo-memory | After tournament (Step 6) → update Ideation Memory via IDE protocol | /direction-summary.md |
| Topic | File |
|---|---|
| Literature tree construction | references/literature-tree.md |
| Problem selection framework | references/problem-selection.md |
| Solution design methodology | references/solution-design.md |
| Tree expansion rules | references/tree-search-protocol.md |
| ELO formula & rubric | references/elo-ranking-guide.md |
| Proposal section guidance | references/proposal-extension.md |
| Baseline feasibility assessment | references/baseline-feasibility.md |
| Idea candidate template | assets/idea-candidate-template.md |
| Ranking scorecard | assets/ranking-scorecard-template.md |
| Direction summary | assets/direction-summary-template.md |
| Proposal example (E-FNO) | assets/proposal-template.md |
© CamusGIT, Apache-2.0. 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 13 other files (references, assets) in EvoQuant/skills/research-ideation of CamusGIT/EvoQuant.
Open the folder on GitHubat commit ac1c4b8
Research Ideation 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 |
|---|---|---|---|---|---|---|
| Research Ideation this skillCamusGIT/EvoQuant | 151 | — | ~5.4k | Automated safety check: Pass | Apache-2.0 | |
| Brainstormingxpinjection/test-driven-spring-boot | 112 | 54 repos | ~2.6k | Automated safety check: Pass | MIT | |
| LLM Councilgcpdev/llm-council-skill | 461 | 1 repos | ~1k | Automated safety check: Notes | MIT | |
| Typesafe AIOpenAgentsInc/openagents | 455 | 9 repos | ~2.5k | Automated safety check: Pass | MIT | |
| Yao Meta Skillyaojingang/yao-meta-skill | 2.7k | — | ~768 | Automated safety check: Pass | MIT | |
| Trellis StartROYIANS/foliq-print-template-designer | 135 | 6 repos | ~646 | Automated safety check: Pass | MIT |
xpinjection/test-driven-spring-boot
You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior.
gcpdev/llm-council-skill
Multi-LLM collaborative brainstorming and planning. An agent skill from gcpdev/llm-council-skill.
OpenAgentsInc/openagents
Build AI-powered software with TypeSafe: small units of AI intelligence you can use like programming primitives.
yaojingang/yao-meta-skill
Create, improve, or evaluate an existing skill from workflows, prompts, SOPs, scripts.
ROYIANS/foliq-print-template-designer
Initializes an AI development session by reading workflow guides, developer identity, git status, active tasks, and project guidelines from .trellis/.
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.
CamusGIT/EvoQuant
Find and read papers from the local papers library (repo papers/, mounted at /papers/).
CamusGIT/EvoQuant
Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and…
CamusGIT/EvoQuant
Convert quantitative research report PDFs to markdown, then extract structured knowledge (paperId, title, year, source, keywords, tldr, abstract, strategy, method, experiment, result) into JSONL…
CamusGIT/EvoQuant
Guides self-review of YOUR OWN academic paper before submission with adversarial stress-testing.
CamusGIT/EvoQuant
Helps users discover agent skills from the open ecosystem. An agent skill from CamusGIT/EvoQuant.
Categories
Quant-focused research ideation pipeline: scope selection (3 stages) → anchor-first literature grounding → single-core idea generation → iterative refinement → ELO tournament ranking (Final =…. Research Ideation is an agent skill from CamusGIT/EvoQuant. Quant-focused research ideation pipeline: scope selection (3 stages) → anchor-first literature grounding → single-core idea generation → iterative refinement → ELO tournament ranking (Final = N+R+C−D) → update evo-memory → user selects direction → expand into manuscript-quality proposal.
Research Ideation fits situations like: : user wants to find a quant research direction; brainstorm ideas within a scope stage; evaluate idea novelty; design a novel solution anchored to an existing paper.
Run `npx skills add CamusGIT/EvoQuant --skill research-ideation -a claude-code`. Or copy the skill folder (EvoQuant/skills/research-ideation in CamusGIT/EvoQuant) into .claude/skills/research-ideation in your project. Claude Code loads it when a task matches its description.
Run `npx skills add CamusGIT/EvoQuant --skill research-ideation -a codex`. Or copy the skill folder (EvoQuant/skills/research-ideation in CamusGIT/EvoQuant) into .agents/skills/research-ideation 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 CamusGIT/EvoQuant --skill research-ideation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/research-ideation, .gemini/skills/research-ideation, .github/skills/research-ideation and .opencode/skills/research-ideation in your project.
SKILL.md names no scripts, command-line tools or credentials: Research Ideation is instructions for the agent only. Its frontmatter pre-approves these tools: write_file, edit_file, read_file, think_tool, execute.
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.
Research Ideation is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 5.4k tokens (SKILL.md is roughly 21k 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 14k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Research Ideation: Brainstorming (xpinjection/test-driven-spring-boot, 112 stars), LLM Council (gcpdev/llm-council-skill, 461 stars), Typesafe AI (OpenAgentsInc/openagents, 455 stars) and Yao Meta Skill (yaojingang/yao-meta-skill, 2.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
CamusGIT (a GitHub user) maintains it in CamusGIT/EvoQuant, which has 151 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on September 2, 2026.
Source: CamusGIT/EvoQuant on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.