hermes-skills/software-development/ideate/SKILL.md

---
name: ideate
description: "Generate, develop, and evaluate ideas for features, products, or solutions. Use when the user wants to explore possibilities, generate options, or find creative directions — not when they already have a specific plan."
version: 1.0.0
author: Hermes Agent (merged from Every Inc compound-engineering ce-ideate)
license: MIT
metadata:
  hermes:
    tags: [ideation, creativity, exploration, brainstorming, compound-engineering]
    related_skills: [brainstorming, tech-pov, plan, compound-learning]
---

# Ideate

Generate, develop, and evaluate ideas. Move from "we need ideas" to a ranked shortlist with rationale — grounded in project context, not generic brainstorming.

**Core principle:** Ideas are cheap; evaluated ideas grounded in real context are valuable. The output is not a list of ideas — it's a ranked, contextualized shortlist with a clear recommendation.

## When to Use

- "What should we build next?"
- "Give me ideas for improving X"
- "How could we approach Y?"
- "What features would make sense for Z?"
- Open-ended exploration before committing to a specific plan

**Not for:** bounded technology decisions (use `tech-pov`), dialog-driven design refinement (use `brainstorming`), or implementation planning (use `plan`).

## The Process

### Phase 1: Frame the Question

Clarify what kind of ideas are needed:

1. **Domain** — what area? (product features, DX improvements, perf, UX, architecture)
2. **Constraints** — budget, timeline, team size, tech stack, must-not-break constraints
3. **Appetite** — incremental improvements vs bold bets vs moonshots
4. **Success criterion** — how will we know a good idea when we see it?

If the user's framing is vague, ask ONE clarifying question. Don't over-interview.

### Phase 2: Ground in Context

Before generating ideas, understand the landscape:

```python
# What does the project already have?
search_files("*", target="files", path="src/")

# Any prior decisions or learnings?
search_files("keyword", path="docs/solutions/")

# Recent git activity — what's being worked on?
terminal("git log --oneline -20")

# Existing strategy or roadmap?
read_file("STRATEGY.md")  # if exists
read_file("ROADMAP.md")   # if exists
```

For broader context, dispatch a research scout:

```python
delegate_task(
    goal="Research the current state of [domain]: what competitors do, what users expect, what's emerging. Return 5-10 key insights relevant to ideation.",
    context="Ideating for [project]. Domain: [area].",
    toolsets=["web"]
)
```

### Phase 3: Generate Ideas

Use multiple generation strategies — different strategies find different ideas:

#### Strategy 1: First Principles
Start from the core problem. What would the ideal solution look like with no constraints? Then add constraints back.

#### Strategy 2: Analogy
What solves similar problems in other domains? (other products, nature, games, manufacturing)

#### Strategy 3: Inversion
Instead of "what should we add?", ask "what should we remove?" Sometimes the best idea is killing a feature.

#### Strategy 4: Constraint Removal
Pick one constraint (budget, tech, timeline) and imagine it's gone. What becomes possible? Can we approximate that within constraints?

#### Strategy 5: User Pain Points
Where do users struggle? What do they complain about? What workarounds do they use?

#### Strategy 6: Compound Leverage
What existing asset, if extended slightly, unlocks disproportionate value? (existing data, user base, infrastructure, brand)

Generate 10-20 raw ideas. Don't filter yet — quantity first.

### Phase 4: Develop Promising Ideas

Select the top 6-8 raw ideas. For each, develop a one-paragraph pitch:

```markdown
### Idea: [Name]
**What:** One sentence describing the idea
**Who benefits:** Target user/stakeholder
**How:** Rough approach (not detailed plan)
**Why now:** What makes this timely?
**Risk:** What could go wrong?
**Effort:** S/M/L rough estimate
```

### Phase 5: Evaluate and Rank

Score each developed idea against consistent criteria:

| Criterion | Weight | Scoring Guide |
|---|---|---|
| **Impact** | 30% | How much value does this create? (user satisfaction, revenue, efficiency) |
| **Feasibility** | 25% | Can we actually build this with current resources/constraints? |
| **Strategic fit** | 20% | Does this align with the project's direction and strengths? |
| **Novelty** | 10% | Is this differentiated or table stakes? |
| **Compound potential** | 15% | Does this unlock future opportunities or leverage existing assets? |

Score each 1-5 per criterion. Calculate weighted score.

### Phase 6: Present Shortlist

Present the top 3-5 ideas as a ranked table:

```markdown
## Idea Shortlist

| Rank | Idea | Score | Impact | Effort | Why |
|---|---|---|---|---|---|
| 1 | [Name] | 4.2/5 | High | M | [one-line rationale] |
| 2 | [Name] | 3.9/5 | High | L | [one-line rationale] |
| 3 | [Name] | 3.7/5 | Medium | S | [one-line rationale] |

### Top Pick: [Name]
[2-3 paragraph explanation of why this is the recommendation]

### Runner-ups
[Brief notes on why #2 and #3 didn't win]

### Parking Lot
[Ideas that didn't make the cut but worth revisiting]
```

### Phase 7: Next Steps

Offer to advance the top pick:
- **Refine** → `brainstorming` for design dialog
- **Decide** → `tech-pov` if it involves a technology choice
- **Plan** → `plan` / `writing-plans` for implementation planning
- **Capture** → `compound-learning` if a strategic insight emerged

## Modes

### Interactive (default)
Walk through phases with user check-ins at Phase 3 (idea dump) and Phase 6 (shortlist).

### Headless
Run all phases without interruption. Return the ranked shortlist as structured output.

## Pitfalls

- **Don't skip grounding** — ideas generated without project context are generic and useless
- **Don't filter during generation** — kill premature criticism; filter in Phase 5
- **Don't present unranked lists** — the value is in the evaluation, not the brainstorm
- **Don't confuse effort with impact** — a small idea with high impact beats a big idea with moderate impact
- **Don't ignore compound potential** — ideas that unlock future options are systematically undervalued
- **Don't over-generate** — 20 raw ideas is plenty; 50 is procrastination

## Integration with Other Skills

- **brainstorming** — ideate generates options, brainstorming refines one chosen direction
- **tech-pov** — ideate explores possibilities, tech-pov gives a verdict on a specific choice
- **plan** — receives the chosen idea and scopes implementation
- **compound-learning** — grounds ideation in prior learnings; captures strategic insights
- **doc-review** — can review the idea shortlist before commitment

## Hermes Agent Integration

- `search_files` — ground in project context
- `read_file` — read strategy/roadmap/learnings
- `terminal` — git log, project analysis
- `delegate_task` — research scouts, parallel idea development
- Web tools — competitive research, trend analysis
- `write_file` — save idea shortlist for reference

## Remember

```
Ground before generating
Quantity first, quality in evaluation
Score against consistent criteria
Lead with the recommendation, not the list
Ideas are cheap; evaluated ideas grounded in context are valuable
```