Idea Darwin

Idea Darwin Engine — an automated idea iteration system that evolves raw ideas through structured competition and selection. Imports ideas from ideas.md, str...

Security Scan

The skill's requirements and instructions are consistent with an idea-iteration tool: it reads an ideas.md, writes structured idea cards and reports, and contains no unexpected external installs or credential requests.

Purpose & Capability

The name/description (automated idea iteration) match the instructions: parse ideas.md, create cards, run rounds, score ideas, and write reports. There are no unrelated env vars, binaries, or install steps requested.

Instruction Scope

SKILL.md instructs the agent to read an ideas.md and create a project directory (config.yaml, cards/, rounds/, reports/, graph/). That's coherent for this tool. However the instructions also tell the agent to trigger on a long list of user phrases (even when the user doesn't explicitly call /idea-darwin), which is broad and could cause unexpected activations. The skill references $ARGUMENTS for CLI-style inputs (a platform variable, not a secret).

Install Mechanism

Instruction-only skill with no install spec and no code files to download or execute. This minimizes supply-chain risk.

Credentials

No credentials, env vars, or config paths are requested. The file operations described (read ideas.md, write project files) are proportionate to the stated purpose.

Persistence & Privilege

The skill does not request always:true and has no elevated platform privileges. It will create and maintain local files (config.yaml, cards/, reports/) in the working directory — expected for its function. Because autonomous invocation is allowed by default and the SKILL.md encourages triggering on many phrases, the combination increases the chance the skill will run without an explicit user command; consider whether you want that behavior.

Assessment

This skill appears to do what it says: it will read your ideas.md and create a project directory with idea cards, round reports, and a config.yaml. It does not request any credentials or install external code. Two practical cautions: (1) SKILL.md tells the agent to auto-trigger on many phrases — if you prefer explicit control, only invoke it manually or change the trigger guidance. (2) The skill will write files in the working directory; run it in a workspace where writing/reading those files is acceptable (or back up sensitive files first). If you want extra safety, inspect the repository homepage, try the skill in a disposable/test folder, and confirm it only reads ideas.md and the created project files before using it on sensitive content.

Idea Darwin Engine

A round-based idea iteration system that treats ideas as competing organisms — scoring, selecting, crossing, and evolving them through structured rounds to surface the strongest concepts.

The metaphor is Darwinian selection: ideas that score well survive and evolve; weak ideas get flagged for the user to decide on; crossbreeding produces novel offspring. This prevents the common failure mode of brainstorming where all ideas stay equally vague forever.

Commands

Command	Description
/idea-darwin init	Initialize: parse ideas.md, create directory structure, config, and initial cards (optional params below)
/idea-darwin round	Execute the next iteration round
/idea-darwin round N	Execute N consecutive rounds
/idea-darwin status	View idea pool status and rankings
/idea-darwin dormant IDEA-XXXX	Put a specific idea into dormancy
/idea-darwin wake IDEA-XXXX	Wake a dormant idea
/idea-darwin	No arguments: show brief status and suggest next step

Arguments are extracted from $ARGUMENTS. If no arguments are provided, show current status and suggestions.

init Optional Parameters

Parameter	Description	Default
--budget <N>	Max ideas to process per round	12
--actions <N>	Max actions per idea per round	2
--disruption <N>	Introduce external stimulus every N rounds (disruption round)	3

Example: /idea-darwin init --budget 8 --actions 3 --disruption 5

These parameters are written to config.yaml and can be manually edited later. Unspecified parameters use defaults.

File Structure

The system maintains this structure in the working directory (created during initialization):

project/
├── ideas.md          # User's raw ideas (read-only — never modify this file)
├── config.yaml       # System configuration and state
├── stimuli.md        # External stimulus entries (user-editable, system read-only)
├── cards/            # Idea cards
│   ├── IDEA-0001.md
│   └── ...
├── rounds/           # Round reports
│   ├── round-000.md
│   └── ...
├── reports/          # Leaderboard and cluster reports
│   └── leaderboard.md
└── graph/            # Relationship graph
    └── relations.json

Idea Numbering

• Format: IDEA-XXXX (4-digit zero-padded, starting from 0001)
• Globally unique — numbers are never recycled, even for dormant or removed ideas
• config.yaml tracks the next available number in next_idea_id
• Each idea card records lineage via parent_ids and child_ids

Idea State Machine

seed → exploring → refining → crossing → validated → dormant

State	Meaning	Available Actions
seed	Just entered the pool	Tagging, card generation, deepen, quick cross-validation
exploring	Exploration phase	Deepen, derive, critique, preliminary cross
refining	Polishing phase	Logic reinforcement, feasibility analysis, risk check
crossing	High-cross phase	Merge with complementary ideas, evaluate fusion quality
validated	Verified	Output MVP plan, generate execution roadmap
dormant	Hibernating	Passive participation in cross and similarity matching only

State transitions are recommended by the system based on scores and action results, but the user always has final say.

Scoring System

6 Scoring Dimensions (1–10 each)

Dimension	Weight	Meaning
Novelty	0.10	Is there a genuine breakthrough, or just repetition?
Feasibility	0.20	Is this technically, resource-wise, and path-wise achievable?
Value	0.20	How much impact would this create if successful?
Logic	0.20	Is it internally consistent, with no obvious gaps?
CrossPotential	0.10	How likely is this to spark something new when combined with other ideas?
Verifiability	0.20	Can we design an experiment or minimum validation path?

Three-Layer Scoring Formula

The scoring is layered so that each layer captures a different strategic lens — Survival measures standalone quality, Development measures growth potential, and Priority blends both with recency and diversity bonuses to prevent the pool from stagnating.

Survival = 0.10×Novelty + 0.20×Feasibility + 0.20×Value
         + 0.20×Logic + 0.10×CrossPotential + 0.20×Verifiability

Development = 0.30×Novelty + 0.30×CrossPotential
            + 0.20×VariationPotential + 0.20×Freshness

Priority = 0.50×Survival + 0.30×Development
         + 0.10×NewIdeaBoost + 0.10×DiversityBonus

• VariationPotential (0–10): How many distinct directions can this idea still branch into. Decreases as more children are derived.
• Freshness (0–10): Has this idea changed recently? Decays when an idea goes unprocessed for several rounds.
• NewIdeaBoost: Newly pooled ideas get +2 for their first 2 rounds, then 0.
• DiversityBonus: Ideas belonging to underrepresented categories in the pool get +1–2.

When scoring, refer to the prompt templates in references/prompts.md.

Initialization Flow

When the user runs /idea-darwin init:

1. Locate ideas.md

   • Check if ideas.md exists in the current directory
   • If not found, use AskUserQuestion to ask for the path

2. Create directories and config

   • Create cards/, rounds/, reports/, graph/
   • Generate config.yaml (merge user-provided optional params; use defaults for unspecified ones):

source:
  ideas_file: "./ideas.md"
counter:
  next_idea_id: 1
  current_round: 0
schedule:
  max_ideas_per_round: 12      # --budget
  max_actions_per_idea: 2       # --actions
disruption:
  trigger_every_n_rounds: 3     # --disruption
  wildcard_budget_ratio: 0.10

• Generate stimuli.md (external stimulus file in the project root) with an initial template and editing instructions

3. Parse ideas.md

   • Identify each independent idea (typically separated by ## headings)
   • Do not modify ideas.md — it is always read-only

4. Generate a card for each idea

   • Assign ID (starting from IDEA-0001)
   • Tag (topic / problem type / stage / style / resource tags)
   • Generate full card following assets/card-template.md format
   • Initial scoring (6 dimensions + 3-layer composite scores)
   • Write to cards/IDEA-XXXX.md

5. Generate round-000.md report

   • List all initial card summaries, scores, and suggested next steps
   • Write to rounds/round-000.md

6. Present results to user

   • Display a summary table of all cards (ID, title, score, suggested action)
   • Inform the user about stimuli.md and how to use it:

     stimuli.md has been created in the project root. Every N rounds, the system randomly selects up to 5 enabled entries as external stimuli to break mental ruts. You can edit this file anytime to add/modify/disable entries. Each entry follows this format:

     ## [Entry Title]
     - status: enabled / disabled
     - [Content description]
     

   • Wait for user confirmation before entering the formal round cycle

Round Execution Flow

When the user runs /idea-darwin round, execute these 9 steps strictly in order:

Step 1: Import New Ideas

• Every round starts by checking the default idea document: read the file pointed to by source.ideas_file in config.yaml
• Compare the default ideas.md against existing cards to identify new additions
• For new ideas: tag → generate card → initial scoring
• New ideas are marked stage: seed and receive the NewIdeaBoost
• This is a mandatory pre-step for every round — the system must not loop only over existing cards while ignoring incremental additions to the source file

Step 2: Update Relationship Graph

• Based on all cards' tags and content, compute inter-idea similarity
• Identify potential cross candidates (high similarity = neighbor-cross candidates; low similarity but complementary = distant-cross candidates)
• Update graph/relations.json

Step 3: Global Score Refresh

• Recalculate the 6-dimension scores for every active idea (not dormant)
• Update Survival / Development / Priority
• Flag: high-potential (Priority > 7), stagnant (unchanged for 3+ rounds), low-potential (Priority < 3)

Step 4: Budget Allocation

Distribute slots according to max_ideas_per_round:

• 25% for newly pooled ideas
• 30% for deepening high-priority ideas
• 20% for deriving from high-potential ideas
• 15% for cross experiments
• 10% for disruption / random exploration

Select ideas by Priority Score descending. Each idea gets at most max_actions_per_idea actions.

Step 5: Decide Actions

For each selected idea, assign actions based on the state machine (see table above). When the state machine is insufficient, use score-driven rules:

• High Novelty + Low Verifiability → deepen
• High Novelty + High CrossPotential → cross
• High Value + Low Feasibility → critique + refine
• High Feasibility + Low Logic → deepen
• High duplication → merge

Step 6: Execute Actions

Process each selected idea in turn. Refer to references/actions.md for detailed execution specs, and references/prompts.md for prompt templates.

Execution flow per idea:

1. Read the full card
2. Follow the corresponding prompt template for the action type — think deeply
3. Produce structured output:
   • Updated card content
   • New derived ideas (auto-assign IDs, update parent_ids/child_ids on both sides)
   • Score changes
   • Discovered risks
   • Suggested next actions
4. Write the updated card file

Newly derived ideas also require full card generation and initial scoring.

Step 7: Validate and Deduplicate

• Run two-layer validation on all newly produced ideas:
  • Layer 1 (Fatal flaw check): Logical contradiction? No real demand? Completely infeasible? Near-duplicate?
  • Layer 2 (Value judgment): Worth continuing? What next? Biggest risk?
• Validation failure → mark validated: false, lower priority, report to user
• The user decides whether to dormant or remove — the system only recommends
• Run similarity check across the entire pool and merge near-duplicates

Step 8: Generate Round Report

Write to rounds/round-XXX.md, including:

• Ideas processed this round and actions executed
• Newly produced idea summaries
• Top 5 score changes (up/down)
• Ideas that failed validation (require user decision)
• Recommended priorities for next round
• If disruption round: which external stimuli were used, which innovation frameworks applied

Step 8.5: Output Round Briefing

After all file updates are complete, output a round briefing directly in the conversation (not written to file) so the user can understand the full picture without opening any files. Format:

## Round N Briefing

### Actions Taken
| ID | Title | Action | Key Output |
|---|---|---|---|
| IDEA-XXXX | ... | deepen/derive/cross/critique/... | One-line summary |

### Card Changes
| ID | Title | Score Change | State Change | Notes |
|---|---|---|---|---|
| IDEA-XXXX | ... | Priority X.XX→X.XX | seed→exploring | Reason for change |

### New Ideas (Detail)

For each newly produced idea this round:

#### IDEA-XXXX: [Title]
- **Source**: [cross/derive/stimulus] from IDEA-XXXX + IDEA-XXXX
- **Core Question**: [one paragraph]
- **Key Insight**: [what's most valuable about this idea]
- **Initial Score**: Priority X.XX (Survival X.XX / Development X.XX)
- **Current Tension**: [biggest unresolved question]
- **Suggested Next Step**: [deepen/derive/cross/critique + specific direction]

### Current Rankings
| Rank | ID | Title | Priority | Stage |
|---|---|---|---|---|

### Next Round Preview
- [Suggested priority actions]
- [Whether a disruption round is coming soon]

### Decisions Needed
> List key decisions the user needs to make this round. Each item **must include the idea's full title** (not just the ID) along with context and suggested options.
> Examples:
> 1. **IDEA-0002 "Learn Coding Agent Tutorial Site" overlaps with IDEA-0004 "Progressive Unboxing Pedagogy"** — Merge or reposition? Suggestion: [...]
> 2. **IDEA-0006 "Auto-Diagnostic Thread" failed validation** — Dormant, pivot, or keep observing?
> 3. **IDEA-0003 "Thermal Management Ontology" downgraded** — Accept downgrade from ontology to structured Excel as first step?
>
> If no user decisions are needed this round, write "No decisions needed this round."

This briefing is the primary interface between the user and the system — keep it complete and readable. The "Decisions Needed" section is the most important interaction point: the system should clearly list decision items with recommendations, rather than leaving the user to discover issues from reports.

Step 9: Save State

• Update all modified card files
• Increment current_round in config.yaml
• Update next_idea_id
• Update reports/leaderboard.md (Top 10 rankings)

External Stimuli and Disruption Rounds

Every trigger_every_n_rounds rounds (default 3), external stimuli are introduced in a "disruption round." The purpose is to prevent the idea pool from converging on a local optimum by forcing fresh perspectives.

External Stimulus File (stimuli.md)

stimuli.md lives in the project root. It is created during initialization and maintained by the user. Format:

## Industry Trend: Embodied AI Accelerating to Production
- status: enabled
- Embodied AI moving from lab to production line in 2026, robot operating costs down 60%

## Tech Shift: Unified Multimodal Model Architecture
- status: enabled
- Vision, language, and code unified into single models, API paradigm changing

## Contrarian View: SaaS Is Dead
- status: disabled
- Open-source + self-hosted deployments replacing traditional SaaS subscriptions

• Each entry: ## heading + status field + content description
• enabled = participates in random selection; disabled = skipped
• Users can add, edit, or toggle entries at any time
• The system only reads this file — never writes to it

Disruption Round Mechanics

1. Shuffle priorities: Give low-priority but novel ideas a chance to surface
2. Distant cross: Force crossbreeding between ideas with non-overlapping tags
3. External stimuli: Randomly select up to 5 enabled entries from stimuli.md
4. Assumption reversal: For top-scoring ideas, ask "What if the core assumption is wrong?"
5. Innovation frameworks: Apply SCAMPER / First Principles / Analogical Transfer / Constraint Reversal / Extreme User Perspective

Each round also reserves wildcard_budget_ratio (default 10%) of slots for non-optimal-path exploration.

Dormancy and Wake

/idea-darwin dormant IDEA-XXXX

1. Read the card, set stage to dormant
2. Record reason and round number in the card's "Dormancy Log"
3. The idea will no longer be selected for deepen/derive, but still participates in cross and similarity matching

/idea-darwin wake IDEA-XXXX

1. Read the card, restore stage to the pre-dormancy state (inferred from history, typically exploring)
2. Update the "Dormancy Log"

The system never auto-dormants any idea. Only the user can make that call.

/idea-darwin status

Read config.yaml and all cards, then output:

• Current round number
• Total ideas in pool (broken down by state)
• Top 10 rankings (by Priority Score descending)
• What was processed in the most recent round
• Suggested next steps

Key Constraints

1. ideas.md is read-only: Never modify the user's ideas.md
2. IDs never recycle: Numbers are never reused under any circumstance
3. Branch limit: Each idea can derive at most 2–3 children per round
4. Per-round dedup: Similarity check is mandatory before a round concludes
5. User control: The system never auto-dormants or removes ideas — only recommends
6. Structured output: Every action must produce structured results
7. Consistent card format: All cards strictly follow assets/card-template.md
8. Traceable reports: Every round report must contain a complete operation log

Reference Files

• references/actions.md: Detailed specs and use cases for each standard action
• references/prompts.md: Prompt templates for each action
• assets/card-template.md: Card file template