Idea Generation

Name: Idea Generation
Author: lingzhi227

lingzhi227/claude-skills

16 installs
255 repo stars
Updated February 27, 2026
lingzhi227/claude-skills

This is a copy of idea-generation by lingzhi227 - installs and ranking accrue to the original listing.

Helps with ai & agent building tasks.

About

idea-generation is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.

idea-generation
AI & Agent Building
AI-coding skill

Idea Generation by the numbers

16 all-time installs (skills.sh)
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/lingzhi227/claude-skills --skill idea-generation

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/lingzhi227/claude-skills/idea-generation.svg)](https://skillselion.com/skills/lingzhi227/claude-skills/idea-generation)

Installs	16
repo stars	★ 255
Last updated	February 27, 2026
Repository	lingzhi227/claude-skills ↗

What it does

Helps with ai & agent building tasks.

Files

SKILL.mdMarkdownGitHub ↗

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 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 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, applications

Key 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()