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

/idea-darwin init

/idea-darwin round

/idea-darwin round N

/idea-darwin status

/idea-darwin dormant IDEA-XXXX

/idea-darwin wake IDEA-XXXX

/idea-darwin

Arguments are extracted from

$ARGUMENTS

init Optional Parameters

--budget <N>

12

--actions <N>

2

--disruption <N>

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

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

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

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

references/prompts.md

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

• 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

External Stimulus File (stimuli.md)

stimuli.md

## 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

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