Idea

---
description: Submit an idea to the opportunity-scout for evaluation and capture in the backlog. Handles evaluation, scoring, and approval decision — but stops there. Use /speckit.start to begin implementation later.
---

## User Input

```text
$ARGUMENTS

If the user input above is not empty, use it as the idea description. If it is empty, ask the user for an idea description before proceeding — do NOT stop the session.

Agent References

Role	Agent File
Scout (evaluation + interview)	.claude/agents/backlog/opportunity-scout.md
Prioritizer (scoring)	.claude/agents/backlog/backlog-prioritizer.md
Ideas Guy (approval)	.claude/agents/backlog/the-ideas-guy.md

Read these agent files when acting in each role to understand the detailed protocols.

Purpose

This command captures requirements through an adaptive interview:

IDEA → scout evaluates → INTERVIEW → summarize → GitHub issue → backlog → score → approve
              ↑              ↑            ↑            ↑            ↑        ↑        ↑
           (auto)      (interactive)   (auto)      (auto)       (auto)   (auto)   (auto)

The human suggests an idea; the scout interviews to gather detail; the system creates a summarized GitHub issue (not raw Q&A), links it in the backlog, then scores and decides.

Implementation happens separately: When ready to implement an approved item, run /speckit.start {ID}.

Execution Flow

Step 1: Parse the Idea

Extract from $ARGUMENTS:

• Description: The feature/enhancement idea
• Category (optional): Feature, Enhancement, Bug, Tech Debt, Infrastructure, Documentation
  • If not specified, infer from description
• Flags:
  • --defer: Skip interview, capture quickly with preliminary scores (status: needs-interview)
  • --fast: Skip interview and detailed reporting (existing option)

If no description provided:

"Please provide an idea description, e.g., /idea Add track interpolation for gaps > 5 minutes"

Defer Mode: If --defer is present, skip Step 3 (Interview) and Step 4 (GitHub Issue). The idea will be captured with minimal detail and marked as needs-interview for later processing via /interview.

Step 2: Scout Evaluation

First, read the opportunity-scout agent definition at .claude/agents/backlog/opportunity-scout.md to understand your role and interview approach.

Then act as the opportunity-scout:

1. Read STRATEGY.md — check current phase, themes, parking lot

2. Read CONSTITUTION.md — check for conflicts

3. Apply hard filters:

   • Can it work offline? (CONSTITUTION requirement)
   • Does it conflict with CONSTITUTION.md?
   • Is it already in the Parking Lot?

4. If hard filter fails → STOP with explanation:

   "This idea can't proceed because: {reason}"

5. Apply soft filters (flag, don't reject):

   • Theme fit uncertain?
   • Phase fit uncertain?
   • Scope unclear?

6. Detect minimal detail — assess if the description provides enough context:

   Indicators of insufficient detail:

   • Very short description (< 10 words)
   • Vague terms without specifics ("improve performance", "make it better")
   • Missing problem statement (what pain does this solve?)
   • No clear scope or boundaries
   • Ambiguous target (who/what is affected?)

   If minimal detail detected and --defer was NOT used:

   "This idea seems to have limited detail. Would you like to:

   A) Proceed with interview — I'll ask questions to gather more detail B) Defer for later — Capture quickly now, complete interview via /interview

   (Tip: Use /idea --defer next time to skip this prompt)"

   Wait for user choice before proceeding.

7. If passes hard filters → proceed to Step 3 (or Step 2a if deferring)

Report: "Scout evaluation: ✅ Passes hard filters" (with any soft filter flags)

Step 2a: Defer Path (if --defer flag)

If --defer is present, skip the full interview:

1. Capture minimal detail: Use only the provided description
2. Skip GitHub issue creation: No issue created yet (will be created during /interview)
3. Proceed directly to Step 5: Add to backlog with status needs-interview

Report: "⏭️ Deferring interview — capturing for later processing"

Continue to Step 5, skipping Steps 3 and 4.

Step 3: Interview (Interactive)

Follow the Interview Mode protocol defined in .claude/agents/backlog/opportunity-scout.md.

Conduct an adaptive conversation to gather enough detail for implementation:

1. Assess what's missing based on the idea type:

   • Feature: What problem does it solve? Who benefits? What does success look like?
   • Enhancement: What's the current limitation? What's the desired behavior?
   • Bug: What's broken? Steps to reproduce? Expected vs actual?
   • Tech Debt: What's the current pain? What's the cleaner state?
   • Infrastructure: What capability is needed? What unblocks?

2. Ask clarifying questions (use AskUserQuestion tool):

   • Start with the most important unknowns
   • Ask follow-up questions based on answers
   • Continue until confident you have enough detail for /speckit.start
   • Typical: 2-5 questions depending on complexity

3. Stop interviewing when you have:

   • Clear problem statement
   • Success criteria or acceptance conditions
   • Key constraints (if any)
   • Scope boundaries (what's in/out)

Example questions by type:

• "What triggers this? User action, system event, or scheduled?"
• "What should happen when X fails?"
• "Is this blocking other work, or nice-to-have?"
• "Should this work offline? (CONSTITUTION requires it)"

Step 4: Create GitHub Issue

Synthesize the interview into a summarized feature description (not raw Q&A):

1. Create a GitHub issue using gh issue create:
   • Title: Clear, actionable (same style as backlog descriptions)
   • Body: Structured summary with sections:

     ##