---
name: hack-ideas
description: Generate evidence-grounded hackathon-winning ideas with deeptech WOW factor, backed by a dataset of 176 real hackathons (412 verified winners) and 23 empirically-derived winning patterns. Two modes. IDEAS - given a hackathon brief (organizer, theme, sponsors, judges), retrieve the most analogous past events, extract what actually won there, and produce 3-4 ideas each built on a genuine technical reframe, tagged with the named pattern it exploits, and citing real precedent winners as receipts. COACH - given a project, pitch, or draft, critique it checklist-style against the winning patterns, citing which past winners prove each point. Use when the user shares a hackathon link, says "I'm doing a hackathon", "what should I build for [X]", "hackathon ideas", "need a winning idea", or wants feedback like "review my pitch", "critique my hackathon project", "will this win", "coach my demo".
argument-hint: "IDEAS: share the hackathon brief - organizer, theme, sponsors, judges, format, prize scale. COACH: paste your project description or pitch draft."
---

# Hack Ideas v3 - Evidence-Grounded

The winning hackathon idea is rarely the most feature-rich or the one solving the biggest problem. It's the one that looks unreal - where the concept alone makes everyone go "how did they even *think* of this, and wait, how does that even *work*?" Underneath, it's almost always simple, available tech used against its grain.

v1 of this skill ran on encoded instinct. v2 added evidence. v3 runs on the full corpus: a dataset of **176 real hackathons** (2024 - Aug 2026) with **412 verified winners**, and **23 named winning patterns** derived bottom-up from every winner record - grouped by the mechanism that made judges say yes (problem selection, credibility, demo mechanics, judge psychology, technical reframes, positioning), never by surface domain. Every idea you produce ships with receipts - actual past winners that prove the pattern works - and an honest risk note. Instinct proposes; the dataset corroborates.

This skill is plain markdown + JSON. Any agent that can read files and run searches can execute it; a standalone single-file variant lives in `PROMPT.md`.

## Two Modes

- **IDEAS** (default): brief in, 3-4 evidence-backed ideas out. Workflow below.
- **COACH**: the user has a project, pitch, or draft and wants it critiqued. Load `references/coach-mode.md` and run the pattern checklist. Trigger on "review my pitch", "critique this", "will this win", or any pasted draft.

## The Evidence Base

| File | Contents | Load when |
|------|----------|-----------|
| `data/events.json` | 176 hackathons: organizer, category, region, date, prize pool, ranked winners with project descriptions + sources | Retrieval step (query it with `jq`/`grep` or your file tools - don't read it whole) |
| `data/patterns.json` | 23 winning patterns, each with evidence entries `{event_id, project}` | Start of either mode |
| `references/patterns.md` | The same 23 patterns, named and annotated, with discriminators and receipts | Fallback if patterns.json is absent; also the canonical pattern *names* |
| `data/research.md` | Full source research doc (all events, prose) | Fallback if events.json is absent - search it, never read it whole |
| `references/retrieval.md` | JSON schemas, query recipes, analogy-matching heuristics | Retrieval step |
| `references/coach-mode.md` | The coach checklist with per-item receipts | Coach mode |
| `references/examples.md` | Two full worked example ideas at the quality bar | When calibrating output quality |

All paths are relative to this skill's directory. If the JSON files are missing, the skill still works: use the fallbacks. Never invent a precedent - if you cannot find a real receipt in the data, say so and tag the idea as pattern-unproven.

## IDEAS Workflow

### Phase 1 - PARSE the brief

Extract from the hackathon context:

- **Organizer + sponsor tech** - what MUST be used? Read the docs like nobody else will: what's the second output mode nobody uses, the primitive underneath the product?
- **Format + window** - in-person or online, 12h or multi-week. The window sets *ambition*, not build time (agents build; you steer loops). In-person favors physical demos; mega-scale online favors polish.
- **The room** - who judges? Sponsor engineers test claims, investors want the reframe as a business, lab staff love seeing their feature subverted, domain judges (doctors, regulators) reward domain truth.
- **Prize scale + region** - mega-scale (100k+ entrants) changes what wins (see pattern *Finished beats clever*); region changes distribution (see *Live where they live*, *Last mile first*, and *Ride the public rails* for India).
- **The convergence zone** - predict what 50 other teams will build. Your ideas must be nowhere near it.

### Phase 2 - RETRIEVE precedents

Load the patterns, then find the **5-10 most analogous past events** in `data/events.json` following `references/retrieval.md`. Match in priority order: same organizer > same sponsor-tech category > same format and scale > same region > most recent. Cite which events you selected and why in one line each.

### Phase 3 - EXTRACT what won and why

For each analogous event: what took first place, the one-line reason it won (from the data, not imagination), and which named pattern it evidences. This produces the *local meta* - what this organizer's judges have actually rewarded. Output this as a short table before the ideas so the user sees the evidence trail.

### Phase 4 - GENERATE with the reframe engine

Generate 12+ candidates; the first 6 are the convergence zone - discard them. Every surviving idea must be built on a genuine technical reframe, one of:

- **A tool used for the output nobody associates it with.** An image model becomes a geometry engine. A speech model becomes a lie detector. The tool couldn't have been meant for this - and it's perfect for it.
- **A representation reframe.** The thing everyone treats as X is secretly Y. Markdown is an agent runtime. A game map is a spreadsheet. Convert the format and the impossible becomes trivial.
- **A systems primitive nobody bothered to build.** A uniform boundary, a data flow running backwards, determinism where the field accepted chaos.
- **A constraint made into the identity.** One API, no backend, offline, CLI-only - embraced as the spine of the product, not worked around.

Force candidates with these questions: What does the sponsor tool produce that isn't its advertised output? What happens run backwards? What format conversion unlocks the impossible? What does everyone run sequentially that could go parallel? What file is secretly executable or queryable? Where is accepted chaos that could be made deterministic? What if the tool's biggest limitation IS the product?

Then **cross against the evidence**: for each surviving candidate, which named pattern from `references/patterns.md` does it exploit, and which 2-3 real past winners prove that pattern lands with judges? Strong ideas usually stack 2-3 patterns (CrossBeam = *Months to minutes* + *The expert at the keyboard*). An idea that exploits no proven pattern needs an explicit justification for why it wins anyway - usually it should be cut.

Selection gates (all must pass): the concept alone makes you lean in (WOW); the trick is nameable in one sentence (Mechanism); a sponsor engineer could verify it on the spot (Verifiable); it feels obvious in hindsight (Inevitability); removing the sponsor tech kills it (Sponsor-essential); 10 other teams would never build it (Non-obvious).

### Phase 5 - PRODUCE

Render 3-4 ideas, each with exactly these sections:

- **Headlines** - 2-4 punchy bullets. Name the tech, name the surprise.
- **The WOW** - one paragraph. The surprising insight, then the exact mechanism underneath it, named so precisely a skeptical engineer either says "that's wrong" or "...oh". Both the lean-in and the mechanism, or it's cut.
- **The Pattern** - the named pattern(s) this exploits, phrased as a move ("this is the Bite the hand move - subvert the sponsor's headline capability"), plus 2-3 precedent winners as receipts with their event and what they did. Real receipts from the data only.
- **The Demo Moment** - the 30-60 second sequence where the WOW becomes self-evident. The demo IS the project; if the WOW can't survive being shown at 90% done, it's the wrong idea.
- **The How** - the pipeline, one stage per bullet, technologies named exactly ("Gemini 2.5 Flash", not "an LLM"), including the surprising stage that carries the WOW.
- **The Build** - agent-native, never clock-native: what an agent one-shots, the hard 20% where a human spends the window, and the smoke and mirrors (what's faked for the demo, what's genuinely real).
- **The Risk** - the honest note. What is most likely to break in the time window, how likely (rough odds), what the fallback demo is if it does, and the precedent for the risk if the data has one (e.g. outline-pass reliability is the same class of risk that sank X at Y). Never omit this; judges forgive scoped-down honesty and punish discovered fakery.

## Coach Mode

The user brings a project, pitch, or demo plan. Load `references/coach-mode.md` and run every checklist item against it: the measured claim, shareable demo moment, dogfood opportunity, knowledge moat, sponsor-essential test, convergence-zone check, and the rest. Each verdict cites the past winners that prove the point. Output the scorecard, then the top 3 highest-leverage fixes.

## Anti-Slop

These MUST NOT appear: "an AI-powered [noun]" (unless the AI usage IS the reframe); "[existing product] but for [domain]"; "[sponsor tech] with a nice UI"; RAG-over-your-docs, chatbots, todo apps, dashboards, NFT marketplaces; "decentralized [anything]" without a mechanism; anything scoped by wall-clock hours; anything needing >30 seconds of explanation before the reframe is visible; any idea whose "how" is just "we called the API"; **any precedent citation not actually present in the evidence base**.