# [IDEA NAME]
> Status: [DRAFT / SPEC / ACTIVE / ARCHIVED]
> Created: [DATE]
> Source inspiration: [LINK or "original"]

## Abstract (2-3 sentences)
What is this? What problem does it solve? Why does it matter?

## The Core Insight
What's the one non-obvious observation that makes this idea work?
(If you can't write this, the idea isn't ready yet.)

## Success Criteria
When is this "done"? List 3-5 verifiable outcomes:
- [ ] [Observable outcome 1]
- [ ] [Observable outcome 2]
- [ ] [Observable outcome 3]

## Minimal Viable Version
Describe the simplest possible thing that would prove the concept works.
(One paragraph. No code yet.)

## Constraints
- Must work with: [tools/stack/dependencies]
- Must NOT require: [what to avoid]
- Scale target: [personal use / team / public]
- Time budget: [hours/days]

## Open Questions
Things I don't know yet that matter:
1. [Question 1]
2. [Question 2]

## Implementation Notes (optional)
Hints for whoever (agent or human) implements this:
- Suggested approach: [rough approach]
- Key risk: [what might go wrong]
- Prior art: [similar things that exist]

## Example Input/Output
Input: [example]
Output: [example]

I have a rough idea I want to turn into an implementation-ready spec.

Rough idea: [YOUR VAGUE IDEA IN NATURAL LANGUAGE]

Help me write a proper idea file with:
1. A precise 2-sentence abstract (what + why)
2. The core non-obvious insight (the thing that makes it work)
3. 3-5 verifiable success criteria
4. The minimal viable version (simplest proof of concept)
5. 3 things an implementer needs to know
6. 2 open questions I should resolve before building

Be precise. Remove vagueness. If something is unclear, ask — don't invent.

Implement this idea spec for my specific context.

Idea spec:
[PASTE IDEA FILE]

My context:
- Environment: [OS, language, tools available]
- Existing codebase: [describe or paste relevant parts]
- Constraints: [anything specific to my setup]

Implementation rules:
1. Follow the success criteria exactly
2. Start with the minimal viable version
3. Ask before adding anything not in the spec
4. Output code + a README explaining how to run it
5. Flag any open questions from the spec that affect implementation

Polish this idea file for public sharing as a Gist.

[PASTE IDEA FILE]

Requirements:
- Abstract should be compelling but honest (no hype)
- Success criteria should be so clear anyone could verify them
- Implementation notes should be context-independent
- Add a "Variations" section: 3 different ways someone might implement this differently
- Add a note: "Implementations welcome — tag me in yours"

Format: clean markdown, no implementation code, pure idea.

I have a quick idea: [ONE SENTENCE]

Extract:
1. Problem solved (1 sentence)
2. Core mechanism (1 sentence)  
3. Minimum viable success criterion (1 testable statement)
4. What I need to figure out before building (top 1-2 questions)

Save as a minimal idea file. I'll flesh it out later.

ideas/
├── active/         ← being built right now
│   └── llm-wiki.md
├── backlog/        ← solid specs, not started
│   └── autoresearch.md
├── draft/          ← rough, needs more thinking
│   └── neural-output.md
└── archived/       ← built or abandoned, kept for reference
    └── old-idea.md

Turn my idea into an idea file. Produce: 1) Abstract (2-3 sentences, what and why), 2) Target user (who benefits), 3) Success criteria (how to know it's done — verifiable), 4) Constraints (budget, tech stack, non-goals), 5) Implementation sketch (steps an agent could follow), 6) Open questions (what I haven't decided yet). Format as a single Markdown file ready to share as a Gist.