
Idea Generation
- 1.4k installs
- 255 repo stars
- Updated February 27, 2026
- lingzhi227/agent-research-skills
idea-generation provides documented workflows for Generate novel research ideas with iterative refinement and novelty checking against literature. Score ideas on Interestingness, Feasibility, and Novelty. Use w
About
The idea-generation skill generate novel research ideas with iterative refinement and novelty checking against literature. Score ideas on Interestingness, Feasibility, and Novelty. Use when brainstorming research directions or validating idea novelty. # Idea Generation Generate and refine novel research ideas with literature-backed novelty assessment. ## Input - `$0` - Research area, task description, or existing codebase context - `$1` - Optional: additional context (e.g., "for NeurIPS", constraints) ## Scripts ### Novelty check against Semantic Scholar ```bash python ~/.claude/skills/idea-generation/scripts/novelty_check.py \ --idea "Adaptive attention head pruning via gradient-guided importance" \ --max-rounds 5 ``` Performs iterative literature search to assess if an idea is novel. ## References - Ideation prompts (generation, reflection, novelty): `~/.claude/skills/idea-generation/references/ideation-prompts.md` ## Workflow ### Step 1: Generate Ideas Given a research area and optional code/paper context: 1. Generate 3-5 diverse research ideas 2. For each idea, provide: Name, Title, Experiment plan, and ratings 3. Use the ideation prompt templates from references ### Step.
- `$0` - Research area, task description, or existing codebase context
- `$1` - Optional: additional context (e.g., "for NeurIPS", constraints)
- Ideation prompts (generation, reflection, novelty): `~/.claude/skills/idea-generation/references/ideation-prompts.md`
- Generate 3-5 diverse research ideas
- For each idea, provide: Name, Title, Experiment plan, and ratings
Idea Generation by the numbers
- 1,379 all-time installs (skills.sh)
- +40 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Ranked #218 of 2,064 Data Science & ML skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
idea-generation capabilities & compatibility
- Capabilities
- `$0` research area, task description, or exist · `$1` optional: additional context (e.g., "for · ideation prompts (generation, reflection, novelt · generate 3 5 diverse research ideas · for each idea, provide: name, title, experiment
- Use cases
- documentation · planning
What idea-generation says it does
# Idea Generation Generate and refine novel research ideas with literature-backed novelty assessment.
Generate 3-5 diverse research ideas 2.
npx skills add https://github.com/lingzhi227/agent-research-skills --skill idea-generationAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1.4k |
|---|---|
| repo stars | ★ 255 |
| Security audit | 2 / 3 scanners passed |
| Last updated | February 27, 2026 |
| Repository | lingzhi227/agent-research-skills ↗ |
How do I use idea-generation for the task described in its SKILL.md triggers?
Generate novel research ideas with iterative refinement and novelty checking against literature. Score ideas on Interestingness, Feasibility, and Novelty. Use when brainstorming research directions o.
Who is it for?
Teams invoking idea-generation when the user request matches documented triggers and prerequisites.
Skip if: Skip when cached docs are missing, the request is a negative trigger, or another sibling skill owns the workflow.
When should I use this skill?
Generate novel research ideas with iterative refinement and novelty checking against literature. Score ideas on Interestingness, Feasibility, and Novelty. Use when brainstorming research directions or validating idea nov
What you get
Step-by-step guidance grounded in idea-generation documentation and reference files.
- research experiment ideas
- deduplicated hypothesis list
- feasibility-grounded direction brief
By the numbers
- Prompt templates sourced from 3 research frameworks: AI-Scientist, AI-Scientist-v2, AI-Researcher
Files
Idea Generation
Generate and refine novel research ideas with literature-backed novelty assessment.
Input
$0— Research area, task description, or existing codebase context$1— Optional: additional context (e.g., "for NeurIPS", constraints)
Scripts
Novelty check against Semantic Scholar
python ~/.claude/skills/idea-generation/scripts/novelty_check.py \
--idea "Adaptive attention head pruning via gradient-guided importance" \
--max-rounds 5Performs iterative literature search to assess if an idea is novel.
References
- Ideation prompts (generation, reflection, novelty):
~/.claude/skills/idea-generation/references/ideation-prompts.md
Workflow
Step 1: Generate Ideas
Given a research area and optional code/paper context: 1. Generate 3-5 diverse research ideas 2. For each idea, provide: Name, Title, Experiment plan, and ratings 3. Use the ideation prompt templates from references
Step 2: Iterative Refinement (up to 5 rounds per idea)
For each idea: 1. Critically evaluate quality, novelty, and feasibility 2. Refine the idea while preserving its core spirit 3. Stop when converged ("I am done") or max rounds reached
Step 3: Novelty Assessment
For each promising idea: 1. Run novelty_check.py or manually search Semantic Scholar / arXiv 2. Use the novelty checking prompts from references 3. Multi-round search: generate queries, review results, decide 4. Binary decision: Novel / Not Novel with justification
Step 4: Rank and Select
- Score each idea on three dimensions (1-10): Interestingness, Feasibility, Novelty
- Be cautious and realistic on ratings
- Select the top idea(s) for development
Output Format
{
"Name": "adaptive_attention_pruning",
"Title": "Adaptive Attention Head Pruning via Gradient-Guided Importance Scoring",
"Experiment": "Detailed implementation plan...",
"Interestingness": 8,
"Feasibility": 7,
"Novelty": 9,
"novel": true,
"most_similar_papers": ["paper1", "paper2"]
}Rules
- Ideas must be feasible with available resources (no requiring new datasets or massive compute)
- Do not overfit ideas to a specific dataset or model — aim for wider significance
- Be a harsh critic for novelty — ensure sufficient contribution for a conference paper
- Each idea should stem from a simple, elegant question or hypothesis
- Always check novelty before committing to an idea
Related Skills
- Upstream: literature-search, deep-research
- Downstream: research-planning, experiment-design
- See also: novelty-assessment
Idea Generation Prompts Reference
Extracted from AI-Scientist, AI-Scientist-v2, and AI-Researcher.
1. Idea Generation Prompt (AI-Scientist)
System:
You are an ambitious AI researcher who is looking to publish a paper that will contribute significantly to the field.User (first idea):
{task_description}
<experiment.py>
{code}
</experiment.py>
Here are the ideas that you have already generated:
'''
{prev_ideas_string}
'''
Come up with the next impactful and creative idea for research experiments and directions you can feasibly investigate with the code provided.
Note that you will not have access to any additional resources or datasets.
Make sure any idea is not overfit the specific training dataset or model, and has wider significance.
Respond in the following format:
THOUGHT:
<THOUGHT>
NEW IDEA JSON:<JSON>
In <THOUGHT>, first briefly discuss your intuitions and motivations for the idea. Detail your high-level plan, necessary design choices and ideal outcomes of the experiments. Justify how the idea is different from the existing ones.
In <JSON>, provide the new idea in JSON format with the following fields:
- "Name": A shortened descriptor of the idea. Lowercase, no spaces, underscores allowed.
- "Title": A title for the idea, will be used for the report writing.
- "Experiment": An outline of the implementation. E.g. which functions need to be added or modified, how results will be obtained, ...
- "Interestingness": A rating from 1 to 10 (lowest to highest).
- "Feasibility": A rating from 1 to 10 (lowest to highest).
- "Novelty": A rating from 1 to 10 (lowest to highest).
Be cautious and realistic on your ratings.
This JSON will be automatically parsed, so ensure the format is precise.
You will have {num_reflections} rounds to iterate on the idea, but do not need to use them all.2. Reflection Prompt (AI-Scientist)
Round {current_round}/{num_reflections}.
In your thoughts, first carefully consider the quality, novelty, and feasibility of the idea you just created.
Include any other factors that you think are important in evaluating the idea.
Ensure the idea is clear and concise, and the JSON is the correct format.
Do not make things overly complicated.
In the next attempt, try and refine and improve your idea.
Stick to the spirit of the original idea unless there are glaring issues.
Respond in the same format as before:
THOUGHT:
<THOUGHT>
NEW IDEA JSON:<JSON>
If there is nothing to improve, simply repeat the previous JSON EXACTLY after the thought and include "I am done" at the end of the thoughts but before the JSON.
ONLY INCLUDE "I am done" IF YOU ARE MAKING NO MORE CHANGES.3. Novelty Check System Message (AI-Scientist)
You are an ambitious AI PhD student who is looking to publish a paper that will contribute significantly to the field.
You have an idea and you want to check if it is novel or not. I.e., not overlapping significantly with existing literature or already well explored.
Be a harsh critic for novelty, ensure there is a sufficient contribution in the idea for a new conference or workshop paper.
You will be given access to the Semantic Scholar API, which you may use to survey the literature and find relevant papers to help you make your decision.
The top 10 results for any search query will be presented to you with the abstracts.
You will be given {num_rounds} to decide on the paper, but you do not need to use them all.
At any round, you may exit early and decide on the novelty of the idea.
Decide a paper idea is novel if after sufficient searching, you have not found a paper that significantly overlaps with your idea.
Decide a paper idea is not novel, if you have found a paper that significantly overlaps with your idea.
{task_description}
<experiment.py>
{code}
</experiment.py>4. Novelty Check Per-Round Prompt (AI-Scientist)
Round {current_round}/{num_rounds}.
You have this idea:
"""
{idea}
"""
The results of the last query are (empty on first round):
"""
{last_query_results}
"""
Respond in the following format:
THOUGHT:
<THOUGHT>
RESPONSE:<JSON>
In <THOUGHT>, first briefly reason over the idea and identify any query that could help you make your decision.
If you have made your decision, add "Decision made: novel." or "Decision made: not novel." to your thoughts.
In <JSON>, respond in JSON format with ONLY the following field:
- "Query": An optional search query to search the literature (e.g. attention is all you need). You must make a query if you have not decided this round.
A query will work best if you are able to recall the exact name of the paper you are looking for, or the authors.
This JSON will be automatically parsed, so ensure the format is precise.5. AI-Scientist-v2: Enhanced Ideation
System:
You are an experienced AI researcher who aims to propose high-impact research ideas resembling exciting grant proposals. Feel free to propose any novel ideas or experiments; make sure they are novel. Be very creative and think out of the box. Each proposal should stem from a simple and elegant question, observation, or hypothesis about the topic.
Ensure that the proposal does not require resources beyond what an academic lab could afford. These proposals should lead to papers that are publishable at top ML conferences.Idea Finalization (v2 fields):
{
"Name": "...",
"Title": "...",
"Short Hypothesis": "A concise statement of the main hypothesis. Clarify the need for this direction, ensure this is the best setting to investigate.",
"Related Work": "Brief discussion of most relevant related work and how the proposal clearly distinguishes from it.",
"Abstract": "Conference-format abstract (~250 words).",
"Experiments": "List of experiments to validate the proposal. Be specific in how you would test the hypothesis and detail precise algorithmic changes. Include evaluation metrics.",
"Risk Factors and Limitations": "Potential risks and limitations of the proposal."
}6. AI-Researcher: Idea Agent
You are an Idea Generation Agent specialized in analyzing academic papers and generating innovative ideas.
OBJECTIVE:
- Conduct thorough literature review of provided papers
- Identify research gaps and challenges
- Generate innovative and feasible ideas
- Provide detailed technical solutions
Generate comprehensive proposals including:
a) Challenges: Current technical limitations, unsolved problems
b) Existing Methods: Summary of approaches, advantages, limitations
c) Motivation: Why the problem is important, gaps to address
d) Proposed Method: Detailed technical solution, mathematical formulations, key innovations
e) Technical Details: Architecture design, algorithm specs, data flow
f) Expected Outcomes: Anticipated improvements, evaluation metrics, applicationsKey Parameters
| Parameter | Default | Description |
|---|---|---|
| max_num_generations | 20 | Ideas per research area |
| num_reflections | 5 | Refinement rounds per idea |
| max_num_iterations (novelty) | 10 | Novelty search rounds |
| result_limit | 10 | Papers per search query |
Scoring Rubric
| Dimension | Range | Description |
|---|---|---|
| Interestingness | 1-10 | Appeal and potential impact |
| Feasibility | 1-10 | Implementation practicality with available resources |
| Novelty | 1-10 | Originality vs existing literature |
#!/usr/bin/env python3
"""Novelty checker for research ideas via Semantic Scholar API.
Iteratively searches literature to assess if a research idea is novel.
Self-contained: uses only stdlib.
Adapted from AI-Scientist's check_idea_novelty() in generate_ideas.py.
Usage:
python novelty_check.py --idea "Adaptive attention pruning via gradient importance"
python novelty_check.py --idea "..." --max-rounds 10
python novelty_check.py --idea-file idea.json
"""
import argparse
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
S2_API_KEY = os.environ.get("SEMANTIC_SCHOLAR_API_KEY", "")
S2_SEARCH_URL = "https://api.semanticscholar.org/graph/v1/paper/search"
FIELDS = "title,authors,venue,year,abstract,citationCount"
def search_semantic_scholar(query: str, limit: int = 10) -> list[dict]:
"""Search Semantic Scholar for papers matching the query."""
params = urllib.parse.urlencode({
"query": query,
"limit": limit,
"fields": FIELDS,
})
url = f"{S2_SEARCH_URL}?{params}"
req = urllib.request.Request(url)
if S2_API_KEY:
req.add_header("X-API-KEY", S2_API_KEY)
for attempt in range(3):
try:
with urllib.request.urlopen(req, timeout=30) as resp:
data = json.loads(resp.read().decode())
return data.get("data", [])
except urllib.error.HTTPError as e:
if e.code == 429:
wait = 2 ** (attempt + 1)
print(f" Rate limited, waiting {wait}s...", file=sys.stderr)
time.sleep(wait)
continue
raise
except urllib.error.URLError:
time.sleep(2)
continue
return []
def format_paper(paper: dict) -> str:
"""Format a single paper for display."""
title = paper.get("title", "Unknown")
year = paper.get("year", "?")
venue = paper.get("venue", "")
citations = paper.get("citationCount", 0)
authors = paper.get("authors", [])
author_str = ", ".join(a.get("name", "") for a in authors[:3])
if len(authors) > 3:
author_str += " et al."
abstract = paper.get("abstract", "") or ""
if len(abstract) > 300:
abstract = abstract[:300] + "..."
venue_str = f" ({venue})" if venue else ""
return (
f" [{year}] {title}{venue_str}\n"
f" Authors: {author_str} | Citations: {citations}\n"
f" Abstract: {abstract}"
)
def generate_search_queries(idea: str) -> list[str]:
"""Generate diverse search queries from an idea description."""
# Extract key phrases by splitting on common delimiters
words = idea.lower().split()
# Strategy 1: Use the full idea as a query (truncated)
queries = [" ".join(words[:15])]
# Strategy 2: Extract noun-phrase-like chunks
# Look for sequences of capitalized words or technical terms
chunks = []
current_chunk = []
for word in idea.split():
if len(word) > 3 and not word.lower() in {"with", "from", "that", "this", "using", "based", "through", "which", "their", "have", "been", "into", "also", "more"}:
current_chunk.append(word)
else:
if current_chunk:
chunks.append(" ".join(current_chunk))
current_chunk = []
if current_chunk:
chunks.append(" ".join(current_chunk))
# Add the longest chunks as queries
chunks.sort(key=len, reverse=True)
for chunk in chunks[:3]:
if len(chunk.split()) >= 2 and chunk not in queries:
queries.append(chunk)
return queries[:5]
def run_novelty_check(idea: str, max_rounds: int = 5, result_limit: int = 10) -> dict:
"""Run iterative novelty checking against Semantic Scholar.
Returns a dict with novelty assessment and similar papers found.
"""
print(f"Checking novelty of idea:")
print(f" \"{idea[:200]}{'...' if len(idea) > 200 else ''}\"")
print()
all_papers_seen = {}
queries_used = []
# Generate initial search queries
search_queries = generate_search_queries(idea)
for round_num in range(1, max_rounds + 1):
if not search_queries:
break
query = search_queries.pop(0)
queries_used.append(query)
print(f"Round {round_num}/{max_rounds}: Searching \"{query}\"")
papers = search_semantic_scholar(query, limit=result_limit)
if not papers:
print(" No results found.")
print()
continue
new_papers = 0
for paper in papers:
title = paper.get("title", "")
if title and title not in all_papers_seen:
all_papers_seen[title] = paper
new_papers += 1
print(f" Found {len(papers)} papers ({new_papers} new)")
for paper in papers[:3]:
print(format_paper(paper))
if len(papers) > 3:
print(f" ... and {len(papers) - 3} more")
print()
# If we got results, try to refine with more specific queries
if papers and round_num < max_rounds and not search_queries:
# Generate follow-up queries from the most relevant paper titles
for p in papers[:2]:
t = p.get("title", "")
if t and len(t.split()) >= 3:
search_queries.append(t[:80])
# Rank by relevance (citation count as proxy)
ranked = sorted(all_papers_seen.values(),
key=lambda p: p.get("citationCount", 0), reverse=True)
result = {
"idea": idea,
"total_papers_found": len(all_papers_seen),
"rounds_used": len(queries_used),
"queries_used": queries_used,
"most_cited_similar": [
{
"title": p.get("title", ""),
"year": p.get("year"),
"venue": p.get("venue", ""),
"citations": p.get("citationCount", 0),
"abstract": (p.get("abstract", "") or "")[:200],
}
for p in ranked[:10]
],
}
print("=" * 60)
print(f"NOVELTY CHECK SUMMARY")
print(f"Total unique papers found: {len(all_papers_seen)}")
print(f"Rounds used: {len(queries_used)}/{max_rounds}")
print()
print("Most cited similar papers:")
for i, p in enumerate(ranked[:5], 1):
print(f" {i}. [{p.get('year', '?')}] {p.get('title', '?')} "
f"(citations: {p.get('citationCount', 0)})")
print()
print("NOTE: Review the papers above to determine if your idea is novel.")
print("An idea is novel if no paper significantly overlaps with it.")
print("=" * 60)
return result
def main():
parser = argparse.ArgumentParser(description="Check research idea novelty via Semantic Scholar")
parser.add_argument("--idea", type=str, help="Research idea to check (text)")
parser.add_argument("--idea-file", type=str, help="JSON file containing idea (must have 'Title' or 'Experiment' field)")
parser.add_argument("--max-rounds", type=int, default=5, help="Max search rounds (default: 5)")
parser.add_argument("--result-limit", type=int, default=10, help="Results per query (default: 10)")
parser.add_argument("--output", type=str, help="Output JSON file for results")
args = parser.parse_args()
if args.idea_file:
with open(args.idea_file, encoding="utf-8") as f:
idea_data = json.load(f)
idea_text = idea_data.get("Title", "") + ". " + idea_data.get("Experiment", "")
if not idea_text.strip(". "):
idea_text = json.dumps(idea_data)
elif args.idea:
idea_text = args.idea
else:
parser.error("Either --idea or --idea-file is required")
return
result = run_novelty_check(idea_text, max_rounds=args.max_rounds,
result_limit=args.result_limit)
if args.output:
with open(args.output, "w", encoding="utf-8") as f:
json.dump(result, f, indent=2, ensure_ascii=False)
print(f"\nResults saved to {args.output}")
else:
print(json.dumps(result, indent=2, ensure_ascii=False))
if __name__ == "__main__":
main()
Related skills
Forks & variants (2)
Idea Generation has 2 known copies in the catalog totaling 17 installs. They canonicalize to this original listing.
- lingzhi227 - 16 installs
- lingzhi227 - 1 installs
How it compares
Pick idea-generation for lightweight in-agent brainstorming when a full AI-Scientist autonomous pipeline is more than you need.
FAQ
What does idea-generation do?
Generate novel research ideas with iterative refinement and novelty checking against literature. Score ideas on Interestingness, Feasibility, and Novelty. Use when brainstorming research directions or validating idea nov
When should I use idea-generation?
Generate novel research ideas with iterative refinement and novelty checking against literature. Score ideas on Interestingness, Feasibility, and Novelty. Use when brainstorming research directions or validating idea nov
What are common prerequisites?
--- name: idea-generation description: Generate novel research ideas with iterative refinement and novelty checking against literature.
Is Idea Generation safe to install?
skills.sh reports 2 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.