---
name: scorpio-ideas
description: Generate evidence-based feature ideas that improve UX for defined user audiences. Consumes project context, PRD, scope docs, and codebase to identify gaps, missing flows, and opportunities. Use when you want to discover what features to build next.
---

# Feature Idea Generator

A systematic methodology for generating evidence-based feature ideas grounded in the actual codebase, product docs, and defined user audiences. Every idea is anchored in what exists today and targets a specific user persona's experience.

This skill is the creative counterpart to **scorpio-roomba** — scorpio-roomba finds what's *wrong*, Feature Idea Generator finds what's *missing*.

## Prerequisites

Before generating ideas, you need:
- A **Project Context document** from **scorpio-project-map** (required)
- Product docs — any combination of:
  - PRD (from **scorpio-project-artifacts**)
  - MVP Scope document
  - README or product description
  - User stories or requirements summary
- Access to the codebase for evidence gathering

If no Project Context exists, run **scorpio-project-map** first.
If no product docs exist, the skill can still run but ideas will be inferred from code and UI rather than stated product goals.

## Generation Phases

```
Phase 1: Absorb       → Consume project context + product docs
Phase 2: Map Journeys → Trace user flows and identify gaps
Phase 3: Explore      → Examine the codebase for evidence
Phase 4: Generate     → Produce categorized, evidence-based ideas
Phase 5: Present      → Deliver prioritized report with routing
```

## Phase 1: Absorb

Read and internalize all available product context.

### Documents to Read

| Document | What to Extract |
|----------|----------------|
| `docs/PROJECT-CONTEXT.md` | Tech stack, architecture, modules, conventions |
| PRD | Goals, target users, user stories, process flows, constraints |
| MVP Scope | What's in scope, what's deferred, success criteria |
| Implementation Plan | Current build phases, what's done vs. planned |
| `README.md` | Product purpose, audience, setup context |
| `CHANGELOG.md` | Recent feature additions, project momentum |

### Build a Mental Model

After reading, you should be able to answer:
- **What** does this product do?
- **Who** are the defined user personas?
- **What** can each persona do today?
- **What** was explicitly deferred or marked out of scope?
- **What** are the stated product goals?

### Document Your Understanding

```markdown
## Product Understanding

### Product Purpose
[1-2 sentences]

### User Personas
| Persona | Description | Primary Needs |
|---------|-------------|---------------|
| [Role 1] | [Who they are] | [What they need] |
| [Role 2] | [Who they are] | [What they need] |

### Current Capabilities
- [What users can do today — list key features]

### Stated Goals
- [Goal 1 from PRD]
- [Goal 2 from PRD]

### Deferred Items
- [Features explicitly deferred in scope docs]

### Product Maturity
[Prototype / MVP / Growth / Mature]
```

## Phase 2: Map Journeys

Trace each user persona's journey through the product and identify gaps.

### Journey Mapping Process

For each persona, map their complete experience:

```markdown
## User Journey: [Persona Name]

### Entry
How do they first arrive? [Sign up, landing page, invite link, etc.]

### Core Loop
What's their primary repeated action?
[Step 1] → [Step 2] → [Step 3] → [Outcome]

### Secondary Flows
What else do they do?
- [Flow A]: [Steps]
- [Flow B]: [Steps]

### Exit Points
Where do they leave or stop?
- [Natural completion]
- [Frustration point]
- [Dead end]
```

### Gap Categories

As you map journeys, look for these gap types:

| Gap Type | Description | Example |
|----------|-------------|---------|
| **Missing Step** | A flow is incomplete — user can start but not finish | Can create items but not edit them |
| **Dead End** | User reaches a state with no obvious next action | Empty dashboard with no onboarding |
| **Friction Point** | A step that's unnecessarily difficult or confusing | Must manually re-enter data that exists elsewhere |
| **Missing Feedback** | User performs action but gets no confirmation | Submit form, nothing visibly happens |
| **Missing Recovery** | No way to undo or recover from mistakes | No edit, no delete, no undo |
| **Missing Information** | User needs data that isn't displayed | No timestamps, no status indicators |
| **Broken Transition** | Awkward handoff between flows | Create flow dumps user to unrelated page |
| **Missing Personalization** | Same experience regardless of user type or history | No preferences, no recent items, no recommendations |

### Document Gaps

```markdown
## Journey Gaps

| # | Persona | Gap Type | Description | Current Behavior | Impact |
|---|---------|----------|-------------|-----------------|--------|
| 1 | User | Missing Step | Cannot edit profile after creation | Must delete and recreate | High |
| 2 | Admin | Dead End | Empty reports page has no guidance | Blank page, no CTA | Medium |
| 3 | User | Missing Feedback | No confirmation after saving | Form clears silently | Medium |
```

## Phase 3: Explore

Examine the codebase to gather evidence for ideas.

### What to Explore

| Area | Why | What to Look For |
|------|-----|------------------|
| **UI routes/pages** | Understand what screens exist | Missing pages, incomplete navigation |
| **API endpoints** | See what operations are possible | CRUD gaps (create exists but no update/delete) |
| **Data models** | Understand what's tracked | Fields that are stored but never displayed |
| **Error handling** | See how failures are surfaced | Generic errors, missing user-friendly messages |
| **Empty states** | Check what users see with no data | Missing onboarding, blank pages |
| **User settings/preferences** | See what's configurable | Missing personalization |
| **Notifications/feedback** | Check how users are informed | Missing confirmations, alerts |

### Evidence Collection

For each potential idea, note the evidence:

```markdown
**Idea**: Add profile editing
**Evidence**:
- `src/routes/profile.tsx` — renders profile but has no edit form
- `server/routes/users.ts` — has GET /users/:id but no PATCH /users/:id
- `src/components/ProfileCard.tsx` — displays fields with no edit affordance
- PRD User Story US-3 mentions "manage profile" but only create was built
```

### Codebase Signals

Look for these signals that suggest missing features:

```
Grep: "TODO|FIXME|HACK" → planned but unbuilt work
Grep: "// future|// later|// v2" → deferred features
Grep: "disabled|hidden|coming.soon" → stubbed-out features
Grep: "placeholder|sample|mock|dummy" → incomplete implementations
```

Also check:
- Routes defined but rendering placeholder/empty components
- Database columns that are never read or displayed
- API endpoints that exist but aren't called from the UI
- Components that are defined but never imported

## Phase 4: Generate

Produce feature ideas organized by category, each grounded in evidence.

### Idea Categories

#### Quick Wins
Low effort, clear UX improvement. Users immediately notice.

| Typical Examples |
|-----------------|
| Add confirmation dialogs for destructive actions |
| Improve empty states with onboarding guidance |
| Add success/error toast notifications |
| Display timestamps and status indicators |
| Add loading states for async operations |

#### Completeness Gaps
Flows that are half-built — the CRUD missing the U or D.

| Typical Examples |
|-----------------|
| Add edit functionality where only create exists |
| Add delete/archive for items that can only be created |
| Add search/filter to lists that will grow |
| Add pagination for unbounded data |
| Complete a flow that stops midway |

#### Growth Features
Would improve user retention, engagement, or acquisition.

| Typical Examples |
|-----------------|
| User onboarding flow for first-time users |
| Email notifications for important events |
| Social sharing for user-generated content |
| Export/import for data portability |
| Invite flow for bringing in new users |

#### Delight Features
Small touches that make users love the product.

| Typical Examples |
|-----------------|
| Keyboard shortcuts for power users |
| Dark mode / theme preferences |
| Undo for recent actions |
| Smart defaults based on user history |
| Contextual help or tooltips |

#### Accessibility Gaps
Missing a11y that limits the audience.

| Typical Examples |
|-----------------|
| Keyboard navigation for interactive elements |
| Screen reader labels for icons and images |
| Color contrast improvements |
| Focus management in modals and dialogs |
| Alt text for meaningful images |

### Idea Format

Each idea follows this structure:

```markdown
### [IDEA-NNN] [Title]

**Category**: Quick Win | Completeness | Growth | Delight | Accessibility
**For persona**: [which user role benefits]
**Impact**: High | Medium | Low
**Effort**: High | Medium | Low
**Priority**: DO FIRST | DO NEXT | CONSIDER | DEFER

**The gap**: [1-2 sentences describing what's missing from the user's perspective]

**Evidence**:
- [Code reference, PRD reference, or journey gap reference]
- [Additional evidence]

**The idea**: [2-3 sentences describing the feature and how it improves UX]

**User benefit**: [1 sentence: what improves for the user]

**Routes to**: scorpio-feature-intake | scorpio-feature-plan
```

### Impact and Effort Ratings

**Impact** — How much does this improve a user's experience?

| Rating | Criteria |
|--------|----------|
| **High** | Removes a major friction point, enables a new workflow, or delights many users |
| **Medium** | Improves an existing flow, adds useful information, or helps a segment of users |
| **Low** | Minor polish, edge case improvement, or benefits few users |

**Effort** — How much work to build?

| Rating | Criteria |
|--------|----------|
| **High** | New module, multiple components, API + UI + data work, needs design |
| **Medium** | Several files, extends existing patterns, moderate complexity |
| **Low** | Single component, follows existing patterns, mostly UI or mostly backend |

### Priority Matrix

```
              │ Low Effort │ Med Effort │ High Effort │
──────────────┼────────────┼────────────┼─────────────┤
High Impact   │ DO FIRST   │ DO NEXT    │ PLAN        │
Medium Impact │ DO NEXT    │ CONSIDER   │ DEFER       │
Low Impact    │ CONSIDER   │ DEFER      │ SKIP        │
```

## Phase 5: Present

Deliver a prioritized report with clear next steps.

### Feature Ideas Report Format

```markdown
# Feature Ideas Report: [Project Name]

**Date**: [date]
**Based on**: Project Context, [list other docs consumed]
**User personas analyzed**: [list]

## Executive Summary

[3-5 sentences: overall product completeness assessment, biggest UX gaps,
and top recommendations. What's the single highest-value thing to build next?]

## Ideas Summary

| Priority | Count | Breakdown |
|----------|-------|-----------|
| DO FIRST | [N] | [N] quick wins, [N] completeness |
| DO NEXT | [N] | [N] completeness, [N] growth |
| CONSIDER | [N] | [N] delight, [N] accessibility |
| DEFER | [N] | [N] growth, [N] delight |

### By Category
- **Quick Wins**: [N] ideas
- **Completeness Gaps**: [N] ideas
- **Growth Features**: [N] ideas
- **Delight Features**: [N] ideas
- **Accessibility Gaps**: [N] ideas

### By Persona
| Persona | Ideas Targeting Them |
|---------|---------------------|
| [Role 1] | [N] ideas |
| [Role 2] | [N] ideas |

## Ideas

### DO FIRST (High Impact, Low-Medium Effort)

[Ideas sorted by impact]

### DO NEXT

[Ideas]

### CONSIDER

[Ideas]

### DEFER

[Ideas]

## Deferred Scope Items

These items were found in the PRD/Scope as explicitly deferred. Noting them
here so they aren't regenerated as "new" ideas:

- [Deferred item 1] — originally deferred because [reason]
- [Deferred item 2] — originally deferred because [reason]

## Recommended Next Steps

1. **[Top idea]** → Route to [scorpio-feature-plan / scorpio-feature-intake]
2. **[Second idea]** → Route to [skill]
3. **[Third idea]** → Route to [skill]
4. **Quick win batch** → [List of quick wins] → Route to scorpio-task-plan directly
```

### User Approval Gate

After presenting the report, **pause for user input**. The user decides:
- Which ideas to pursue
- Which to defer or dismiss
- The order to work on them
- Whether ideas need refinement (→ scorpio-feature-intake) or are ready for design (→ scorpio-feature-plan)

Do not automatically trigger downstream skills.

## Routing Rules

| Idea Readiness | Route To | When |
|----------------|----------|------|
| Well-defined, clear scope | **scorpio-feature-plan** | Behavior, location, and constraints are obvious from the evidence |
| Needs user input on details | **scorpio-feature-intake** | Multiple valid approaches, user preferences matter |
| Batch of quick wins | **scorpio-task-plan** | Simple enough to go straight to tasks (empty states, toasts, etc.) |

## Competitive Context (Optional)

If the product category is known, consider features common in the space:

```markdown
## Competitive Context

**Product category**: [e.g., Podcast hosting platform]

### Common features in this space (not yet in this product)
| Feature | Common In | Relevance |
|---------|-----------|-----------|
| Analytics dashboard | Most competitors | High — users expect listener stats |
| RSS feed generation | All competitors | High — table stakes for podcast hosting |
| Social sharing | Most competitors | Medium — nice to have |
| Monetization tools | Premium competitors | Low — future consideration |
```

This section is optional and should only be included when the product category is obvious and the comparison is useful. Do not fabricate competitor analysis — base it on general knowledge of the product space.

## Relationship to scorpio-roomba

scorpio-roomba and Feature Idea Generator are complementary:

| | scorpio-roomba | Feature Idea Generator |
|---|--------|----------------------|
| **Focus** | What's wrong | What's missing |
| **Looks at** | Code quality, bugs, security | User journeys, UX gaps, product completeness |
| **Output** | Fix findings | Build ideas |
| **Routes to** | scorpio-bug-investigate, scorpio-task-plan | scorpio-feature-plan, scorpio-feature-intake |

They can be run together for a complete codebase assessment:
```
scorpio-project-map → scorpio-roomba (what's wrong) + scorpio-ideas (what's missing)
```

## What NOT To Do

- Do not suggest features that are already implemented (check the codebase)
- Do not suggest features that are explicitly deferred without acknowledging the deferral
- Do not generate generic ideas disconnected from the actual product ("add AI chatbot")
- Do not provide ideas without evidence from code, docs, or journey analysis
- Do not overwhelm with 50 ideas — focus on the top 10-15 most impactful
- Do not make assumptions about user preferences — flag those as needing discovery
- Do not trigger downstream skills automatically — present and let the user choose
- Do not ignore the existing tech stack when estimating effort
- Do not suggest features that contradict stated product constraints

## Skill Chain

This skill feeds into the feature development pipeline:

```
scorpio-project-map + product docs → scorpio-ideas
    │
    ├── Well-defined ideas  → scorpio-feature-plan → scorpio-execute → scorpio-qa-final → scorpio-qa-rework
    ├── Needs refinement    → scorpio-feature-intake → scorpio-feature-plan → ...
    └── Quick win batches   → scorpio-task-plan → scorpio-execute → scorpio-qa-final → scorpio-qa-rework
```