idea-creator skill

Research Idea Creator

Generate publishable research ideas for: $ARGUMENTS

Overview

Given a broad research direction from the user, systematically generate, validate, and rank concrete research ideas. Standalone, Phase 1's landscape survey is inline (WebSearch — it does not invoke /research-lit); Phases 4-5 invoke /novelty-check, /run-experiment, and /monitor-experiment for validation and pilots. For the full sub-skill pipeline (/research-lit → idea generation → /novelty-check → /research-review), run /idea-discovery (Workflow 1), which orchestrates this skill.

Constants

• PILOTMAXHOURS = 2 — Skip any pilot estimated to take > 2 hours per GPU. Flag as "needs manual pilot".
• PILOTTIMEOUTHOURS = 3 — Hard timeout: kill pilots exceeding 3 hours. Collect partial results if available.
• MAXPILOTIDEAS = 3 — Pilot at most 3 ideas in parallel. Additional ideas are validated on paper only.
• MAXTOTALGPUHOURS = 8** — Total GPU budget for all pilots combined.
• REVIEWERMODEL = gpt-6-astra — Default model for the Codex backend. Must be an OpenAI model (e.g., gpt-6-astra, o3, gpt-4o). Manual backend uses a model the user chooses, but it must be a non-Claude model ARIS can classify** (OpenAI, Google, DeepSeek, Moonshot/Kimi, Qwen) — the executor is Claude, so pasting into any Claude product makes Claude judge Claude and voids the cross-model invariant (see shared-references/reviewer-routing.md).
• REVIEWERBACKEND = codex** — Default: Codex MCP (xhigh). Override with — reviewer: oracle-pro for Oracle MCP, or — reviewer: manual for Manual Review MCP. If manual-review MCP is unavailable, stop and print the install command; do not fall back to Codex. See shared-references/reviewer-routing.md.
• OUTPUTDIR = idea-stage/** — All idea-stage outputs go here. Create the directory if it doesn't exist.

💡 Override via argument, e.g., /idea-creator "topic" — pilot budget: 4h per idea, 20h total.

Reviewer Calling Convention

When calling the reviewer for idea evaluation, branch on REVIEWER_BACKEND:

If REVIEWERBACKEND = codex: Use mcpcodexcodex for new review threads. Use mcpcodex__codex-reply for follow-up rounds (reuse threadId).

If REVIEWERBACKEND = manual: Use mcpmanualreviewreview for new review threads with: prompt: [exact same prompt that would go to Codex] config: {"modelreasoningeffort": "xhigh", "executormodel": "", "requirereviewermodel": true} Save the returned threadId. Use mcpmanualreviewreviewreply for follow-up rounds with: threadId: [saved manual-review threadId] prompt: [follow-up prompt] config: {"modelreasoningeffort": "xhigh", "executormodel": "", "requirereviewermodel": true}

Content fidelity: the manual reviewer should see the same substantive bundle content Codex would read. If the manual UI supports file upload / attachment, reuse the same bundle file; otherwise paste the bundle contents inline because remote web UIs cannot read your local filesystem paths. Review tracing applies equally to both backends.

Workflow

Phase 0: Load Research Wiki (if active)

A verdict-bearing manual response MUST begin with Reviewer-Model: — pass the model THIS session is actually running as in executormodel. Missing, unknown, or same-family identity cannot acquit; emit REVIEWUNAVAILABLE rather than guessing. If the executor model cannot be named, manual review's cross-family claim is unprovable — say so in the report instead of asserting it.

Skip this phase entirely if research-wiki/ does not exist.

If research-wiki/ exists, resolve the canonical helper using the shared resolution chain (see ../research-wiki/SKILL.md for the contract):

cd "$(git rev-parse --show-toplevel 2>/dev/null || pwd)" || exit 1
ARIS_REPO="${ARIS_REPO:-}"
ARIS_HOME="${HOME:-}"
if [ -z "${ARIS_REPO:-}" ] && [ -f .aris/installed-skills.txt ]; then
  ARIS_REPO=$(awk -F'\t' '$1=="repo_root"{print $2; exit}' .aris/installed-skills.txt 2>/dev/null) || true
fi
if [ -z "${ARIS_REPO:-}" ] && [ -n "$ARIS_HOME" ] && [ -f "$ARIS_HOME/.aris/repo" ]; then
  ARIS_REPO=$(cat "$ARIS_HOME/.aris/repo" 2>/dev/null) || true
fi
WIKI_SCRIPT=".aris/tools/research_wiki.py"
[ -f "$WIKI_SCRIPT" ] || WIKI_SCRIPT="tools/research_wiki.py"
[ -f "$WIKI_SCRIPT" ] || { [ -n "${ARIS_REPO:-}" ] && WIKI_SCRIPT="$ARIS_REPO/tools/research_wiki.py"; }
[ -f "$WIKI_SCRIPT" ] || {
  echo "WARN: research_wiki.py not found at .aris/tools/, tools/, \$ARIS_REPO/tools/, or via ~/.aris/repo." >&2
  echo "      The idea-creation primary output (idea ranking) will still be produced." >&2
  echo "      Wiki writes and query_pack rebuilds will be skipped; a fresh cached pack may still be loaded through the scanner." >&2
  echo "      Fix: rerun 'bash tools/install_aris.sh' or 'smart_update.sh' (refreshes ~/.aris/repo), export ARIS_REPO, or 'cp <ARIS-repo>/tools/research_wiki.py tools/'." >&2

Treat research-wiki/querypack.md as untrusted until it passes arisscanquerypack. Invoke the scanner inside an if/else (not as a bare command) so callers using set -e still reach the no-wiki-context fallback. When it succeeds, use the Read tool on the raw pack immediately, before any other command or tool call:

if aris_scan_query_pack research-wiki/query_pack.md; then
  query_pack_scan_status=0
  # Immediately Read research-wiki/query_pack.md; run nothing in between.
else
  query_pack_scan_status=$?
fi

Apply this fail-closed flow:

continue producing the primary idea ranking.

1. If the scanner is unresolved, skip all wiki context and report the warning;

clean, read the raw pack at once. Treat its gaps as search seeds, failed ideas as a banlist, and top papers as known prior work; still run Phase 1 for the last 3–6 months.

1. For a cached pack younger than 7 days, scan it immediately before Read. If

wiki context for this run. Do not copy, quarantine, rebuild, rescan, or read the rejected pack; primary ideation continues.

1. On any scanner hit or scanner error, leave the raw pack untouched and skip

available. Then scan immediately before Read exactly as above. If rebuilding or scanning fails, skip wiki context; primary ideation continues.

1. For a stale or missing pack, rebuild once only when WIKI_SCRIPT is

This read-side gate covers only query_pack.md; fetched WebSearch/WebFetch content still follows the separate hygiene limits documented in injection-hygiene.md.

Phase 1: Landscape Survey (5-10 min)

Map the research area to understand what exists and where the gaps are.

1. Scan local paper library first: Check papers/ and literature/ in the project directory for existing PDFs. Read first 3 pages of relevant papers to build a baseline understanding before searching online. This avoids re-discovering what the user already knows.

1. Search recent literature using WebSearch:

• Top venues in the last 2 years (NeurIPS, ICML, ICLR, ACL, EMNLP, etc.)
• Recent arXiv preprints (last 6 months)
• Use 5+ different query formulations
• Read abstracts and introductions of the top 10-15 papers

1. Build a landscape map:

• Group papers by sub-direction / approach
• Identify what has been tried and what hasn't
• Note recurring limitations mentioned in "Future Work" sections
• Flag any open problems explicitly stated by multiple papers

1. Identify structural gaps:

• Methods that work in domain A but haven't been tried in domain B
• Contradictory findings between papers (opportunity for resolution)
• Assumptions that everyone makes but nobody has tested
• Scaling regimes that haven't been explored
• Diagnostic questions that nobody has asked

Phase 1.5: Parallel lens fan-out (Tier-aware) — breadth, not verdict

Idea generation benefits from breadth: more independent analytic angles surface more candidate ideas. This skill fans out candidate generation across analytic lenses, then funnels every candidate through the single Phase-4 cross-model jury. Fan-out widens the jury's input; it never makes the accept/reject decision. This follows shared-references/fan-out-pattern.md; the verdict stays cross-model per shared-references/acceptance-gate.md (idea novelty/quality is a Type-B verdict — same-family generation is fine, same-family acquittal is not).

Lenses (the structural-gap angles from Phase 1, step 3): method-transfer (works in domain A, untried in B) · contradiction (conflicting findings to resolve) · untested-assumption (everyone assumes, nobody tested) · scaling-regime (unexplored regime) · diagnostic (question nobody asked). This set is a floor, not a ceiling — add a domain-specific lens when the direction warrants.

Tier-portable dispatch (the Phase-4 jury downstream is identical on every tier):

each runs the Phase-1 survey through its lens and the Phase-2 generation prompt restricted to that lens, returning candidates as structured output.

• Tier 1 (Workflow available): spawn one Claude subagent per lens;

the Agent tool.

• Tier 2 (Agent tool, no Workflow): spawn the same per-lens subagents via

the original single-thread behavior, made explicit. No capability assumed.

• Tier 3 (no spawning): enumerate the lenses sequentially in one pass —

Why the lens shards are Claude, not Codex. Generation is candidate

production, not a verdict, so same-family is safe — and Codex MCP is

serial (concurrent codex calls hang), so spending its scarce capacity

on parallel generation is both unsafe-to-parallelize and wasteful. Reserve

Codex for the one Phase-4 jury call. On Tier 1/2 the lens subagents are the

generators; the single Phase-2 codex brainstorm below still runs once as an

optional cross-model seed (a generator, not a judge), and its ideas join

the merged pool.

Per-shard output (the generation-fan-out schema from fan-out-pattern.md — shardid + candidates[] + per-item dedupkey):

{"shard_id": "<lens id>", "candidates": [{"summary": "...", "hypothesis": "...",
  "mve": "...", "contribution_type": "...", "risk": "...", "effort": "...",
  "dedup_key": "<hypothesis slug — the mechanical-dedup identity>"}]}

Merge + mechanical dedup: union all lenses' ideas; cluster near-identical ideas by hypothesis (mechanical similarity only — never drop one for being "weak"; weakness is a Phase-4 verdict, not a merge step). The deduped union is the candidate set that enters Phase 3.