WhyC — Gate H1: pick from all 26 advocates

One-shot CLI: paste YC job URL → stream agent trace to stdout for ~10min → first deploy URL prints inline with spec-fit % → background loop continues, sends a final email when converged. Demo shows curl invocation on a synthetic JD and the email arriving with a working preview link. | surface: Terminal (CLI + curl) with email delivery — `curl whyc.sh -d url=...` returns a streaming SSE log of the agent loop; final Cloud Run URL is delivered by plaintext email when spec-fit converges. No web UI for WhyC itself.

Long-horizon agent reasoning across the Phoenix MCP self-improvement loop — Gemini ADK plans which flows are under-spec from trace data, regenerates only those, and narrates each iteration as terminal-grade structured logs (no JSON pretty-printing, no spinners, just timestamped lines a tail-follower can grep).

Single live status board page wired to one synthetic preview job: shows real-time spec-fit score climbing, regen counter, $-per-preview burn, and one fired alert with Opus-generated root-cause annotation — proves observability is shippable in 4 days | surface: Live operations dashboard: status board grid (uptime, p95 latency, spec-fit %, regen-cost-per-preview), Phoenix trace alert feed, audit log of every regen decision, and on-call runbook cards — what every operator stares at all day

Long-context Phoenix trace summarization (1M ctx) — Opus 4.7 reads the entire OpenInference trace tree for a stalled preview and emits a 3-line root-cause + suggested runbook step, surfaced as alert annotations on the ops board

4-day demo: working URL input → Gemini spec extraction → Next.js scaffold → Cloud Run deploy → first spec-fit score visible. Self-improvement loop wired but limited to 2 iterations for demo timing. | surface: Single-page web landing: one URL input, one 'Ship it' button, prefilled example, 3-step onboarding (paste → watch → wake up converged), live agent log strip. No signup for first preview.

Long-context spec extraction from a job posting plus rapid full-stack codegen — exactly the path that turns a one-line input into a deployable Next.js artifact in under 10 minutes of pipeline time.

단일 화면: URL 입력 → 실시간으로 누적 비용 카운터가 0.00달러부터 올라가는 게 보이고, 24h 후 deployed URL과 함께 '총 지출: $0.043' 영수증을 PDF로 발급. self-improvement loop의 각 iteration이 비용을 얼마나 더 썼는지 라인으로 표시. | surface: Next.js static export → Cloud Run min-instances=0, Phoenix free-tier (50k traces/mo), Gemini free quota first, Secret Manager 무료 6 secrets 한도 내. 모든 컴포넌트 옆에 '$/월' 스티커.

Opus 4.7의 cost-aware planning 능력 — agent가 각 노드에서 'Gemini Flash로 충분한가 vs Pro 필요한가' 판단해서 토큰 예산을 절감. 1M context로 Phoenix trace 전체를 한 번에 읽어 redundant LLM 호출 제거.

One pixel-perfect hero screen for the 4-day demo: headline + lede + dual CTA, four trust metrics, and the animated preview-window component showing the spec-fit climb and 4-step loop strip. No second viewport, no scroll narrative — the hero alone closes the pitch. | surface: Editorial-grade landing hero: oversized display headline 'While they hire, we ship.' with strike-through animation, paired with a tilted living preview window that shows a generated Cloud Run URL, a 71→84→92→96 spec-fit climb on the Phoenix self-improvement loop, and a quiet float-quote dagger. Polish-rich, animated entrance, abstract inline-SVG product imagery (no real logos), warm-paper background with OKLCH YC-orange parody as the only accent.

Long-context aesthetic synthesis — Opus 4.7 reads the entire idea spec (constraints, tone, hybrid UX cadence, trademark hygiene) and resolves it into a single coherent visual system: typography weights, OKLCH gradients, motion timing, copy rhythm, and the hero-as-pitch composition all aligned without needing per-element prompts.

• Contrast: oklch(38% 0.012 60) on warm paper borderline 4.5:1 -> tighten to >=4.6:1.
• Add :focus-visible outlines on .nav-cta/.btn-primary/.btn-ghost.
• Mobile float-card overlap with metrics row at <960px -> reposition static below preview.

4-day demo: one populated leaderboard page rendering 12 anonymized portfolio rows with live spec-fit % from real Phoenix traces, sortable by 3 columns, one-click 'Re-run loop' per row triggering ADK pipeline; CSV export stub. | surface: Dense leaderboard table — sticky header row, sticky first column (company), sortable by every column (spec-fit %, days-since-DemoDay, jobs-posted, last-deploy-Δ, judge score), multi-select filter chips, column resizers, keyboard shortcuts (J/K row nav, /-search, S-sort, F-filter, R-rerun), per-row inline sparkline of spec-fit convergence (71→84→92→96), pivot/group-by batch, footer status bar with row count + selection aggregates

Long-context multi-row reasoning — Opus 4.7 ingests Phoenix trace dumps for dozens of generated previews simultaneously, computes per-flow LLM-as-judge deltas across iterations, and emits structured row-level diagnostics (spec_fit, weakest_flow, regen_eta) that populate the grid without per-cell round-trips

Paste-URL hero → live run card with 4-step pipeline + animated spec-fit gauge (71% → background) → bottom 'Ship it in 10 min' CTA. One screen, no signup, push notif on convergence. | surface: Mobile PWA, single-column 375px, sticky 56px bottom CTA in thumb zone, 4-tab bottom nav, paste-from-clipboard hero, push notif when 10-min Cloud Run URL is ready.

Long-context spec extraction from a single pasted JD URL plus continuous LLM-as-judge scoring against the deployed preview during the background self-improvement loop — both phases stream status payloads small enough for mobile data.

One Slack slash command (/whyc ) that triggers the full pipeline, posts an in-channel ephemeral 'analyzing...' message that updates with live spec-fit %, DMs the requester progress milestones, and finally edits the original message to include the deployed Cloud Run URL preview unfurl. | surface: primary_surface = Slack bot (slash command /whyc + URL unfurl + DM progress + channel post). Web dashboard at whyc.app/r/ is auxiliary — only for the converged spec-fit report and the live preview iframe.

Long-running async agent orchestration with conversational checkpoints — Gemini ADK pipeline streams structured progress events that map cleanly to Slack Block Kit message updates, while the self-improvement loop runs for hours and posts delta notifications when spec-fit crosses thresholds.

Single command `whyc ` that streams ASCII spec-extraction → codegen → Cloud Run deploy → returns URL in ~10min, then tails Phoenix self-improvement loop in background (notify-send on each spec-fit jump). | surface: CLI (npx + brew install whyc) drives the pipeline; the deployed Cloud Run URL is the web artifact (hackathon platform requirement satisfied). Web auth handshake handled via short-lived browser callback only.

Long-running streamed agent telemetry — Opus 4.7 emits structured ADK + Phoenix MCP events as ANSI-friendly progress frames, then surfaces LLM-as-judge spec-fit deltas as the background self-improvement loop converges.

4-day demo: one ambient command bar + live aurora visualization of 3 parallel pipelines converging in real time (10min foreground → background loop), with a 'Demo Day mode' toggle that fast-forwards a synthetic 200-company batch as a speculative preview overlay. Real demo uses the locked stack (Gemini ADK + Phoenix + Cloud Run + Next.js); the 200-company swarm is rendered as believable simulated state on top of 3 real pipelines. | surface: Ambient natural-language command surface — no forms, no dropdowns. A single conversational seam where the user narrates intent and a live swarm-state aurora visualizes ~200 parallel ship-loops. Predictive: the agent pre-deploys variants before you ask, surfaces the one that fits your taste. Surprise UX: the build is already done by the time the modal opens.

Opus 4.7's million-token context + agentic horizon: a single planning agent holds the entire accelerator portfolio (200 specs, traces, judge verdicts, founder taste profiles) in working memory and orchestrates thousands of sub-agents (ADK runtimes) without losing coherence. Edge-of-capability: cross-portfolio meta-learning — the loop learns from every batch's failure modes and pre-corrects the next one's spec extraction before regeneration is needed.

One run-detail page that shows: current spec-fit score (big number), iteration strip (0.71 → 0.84 → 0.92), per-flow score table with judge notes, live trace tail, and a static preview thumbnail. That is the entire demo. URL submission and deploy can be a hardcoded fixture for the 4-day cut. | surface: Plain Next.js app (pages router is fine), Postgres for run history, server-sent events for the live score updates, deployed on Cloud Run. Classic left-sidebar SaaS dashboard. No design system, no animations beyond a pulse dot, no dark mode. Stack is 3 years old and that is the point.

Long-context spec extraction + LLM-as-judge scoring across full Phoenix trace tails — Opus reads the entire OpenInference span tree per flow and emits a structured score + one-line judge note that we render verbatim in the table

• Hardcoded URL fixture admitted by P11 -- wire live URL->deploy on stretch-day pre-submission.
• Mobile breakpoint: 220px sidebar + 1fr/360px split breaks below 900px.

Stealth-Mode toggle that, when ON: scrubs company/founder/batch tokens before any Gemini call, sets disableDataLogging on ADK, deploys the Cloud Run preview as private with a 24h signed URL + image-TTL, and routes Phoenix traces to a self-hosted Phoenix endpoint. Demoable as a single switch with a live 'what leaves your project' redacted-trace panel. | surface: Web (Next.js) with browser-side XChaCha20 encryption of URL/spec, run-scoped data residency (us-central1 pinned), ephemeral 24h-signed Cloud Run preview, opt-in self-hosted Phoenix to keep OpenInference traces inside the user's VPC instead of Phoenix Cloud.

Long-context reasoning over the full hackathon-locked stack to (a) trace every PII/identifier flow across ADK -> Agent Builder -> Cloud Run -> Phoenix MCP and (b) auto-generate the redaction rule manifest + threat-model copy that matches each submission's stealth posture.

One screen: live Phoenix dashboard for a single in-flight WhyC run. Spec-fit time-series (animated), iteration bar chart (token cost), 6-flow heatmap (regen count per flow), 4 KPI tiles, and a 'convergence verdict' banner. Demo plays a 30-second replay of iterations 1→7. | surface: Dashboard + time-series + cohort + funnel is primary. Spec-fit-over-time line chart, per-iteration token-spend bars, regenerated-flow heatmap, KPI tiles (current spec-fit %, iterations, $ spent, convergence ETA), and a flow-by-flow funnel showing which flows passed the LLM-as-judge.

Long-context trace correlation: Opus 4.7 reads the full OpenInference trace tree (often 200K+ tokens across iterations) and authors the analyst-grade narrative beneath each chart — 'iteration 4 regenerated /pricing because spec-fit dropped 12pts when the judge flagged missing tier comparison' — turning raw spans into board-ready commentary.

One demo path: paste a synthetic JD URL, watch the 4-stage pipeline run with a live progress bar, hover any stage to see a tooltip lesson ('Why extract spec before code? Because spec-fit becomes your eval rubric'), and finish with a recap card listing 3 takeaways the founder can apply to their own startup tomorrow. | surface: Web app with an inline 'Build Academy' overlay: a persistent progress bar across the 4 agent stages, contextual tooltips on every UI affordance ('Why a hybrid sync model?'), a friendly toast tutor that explains each Phoenix trace as it streams, and a 'Lesson Recap' card after each iteration of the self-improvement loop.

Long-context pedagogical reasoning — Opus 4.7 simultaneously generates the Next.js preview AND a parallel narration track explaining each architectural choice (token budget, eval rubric, why this LLM-as-judge prompt) grounded in the OpenInference trace.

4-day demo: public gallery seeded with 12 synthetic-JD previews across 3 cohort rooms. Anyone (no login required for browse) can paste a JD to add a card; verified hackers (magic link) can vote, @mention, and comment. Live spec-fit score badge updates as the self-improvement loop runs in background. | surface: Public gallery web app — single workspace where every visitor is a member. Role-based access (anon viewer / verified hacker / mod), @mentions on preview cards, reactions (ship-it, lol, oof), threaded comments, shared 'cohort rooms' per YC batch. Real-time presence dots on hot cards.

Long-context aggregation across hundreds of generated previews + comment threads to surface 'this batch's most-shipped vs most-stalled' meta-takes; multi-agent orchestration where each member's submission becomes a tracked artifact in Phoenix MCP with shared spec-fit scores visible to all.

Personal queue panel: paste URL, set budget cap and quiet hours, hit Ship. One row per run with live spec-fit %, cost-so-far, and a single Kill switch. Demo shows the overnight job converging from 71% to 96% while the founder sleeps. | surface: Single-account web admin panel. No teams, no roles, no invites. Owner = admin = user. One Google login, one Cloud Run project, one queue. Settings page is honest about cost ceilings and notification minimalism.

Long-horizon agentic orchestration with sustained tool-use across the overnight self-improvement loop, plus structured cost/spec-fit reasoning that fits a single-operator's mental model (one number to watch, one button to kill).

• P16 budget-cap + Kill switch + quiet-hours UX is canonical -- adopt as reference even if another candidate wins H1.

Single screen: SSO-authenticated diligence dashboard for one prospect — header with SAML/SOC2/residency badges, left rail = spec-fit timeline (71% → 96%), center = embedded Cloud Run preview, right rail = live audit log of every agent action with trace IDs. | surface: SAML/SCIM-gated diligence portal with audit log stream, data-residency toggle, SOC2 evidence vault, and embedded preview iframe — every spec-fit score timestamped and immutable.

Long-context reasoning over Phoenix OpenInference traces to produce auditor-ready provenance chains: every spec-fit delta tied to a trace ID, judge prompt hash, and regenerated flow — exportable as evidence for IC memos.

Day-4 demo: the WhyC landing scroll-story is fully designed and implemented; the 'spec-fit slider' is wired to 4 frozen iframe snapshots (71% / 84% / 92% / 96%) of one synthetic case so judges can drag through the convergence themselves. | surface: Long-form scroll-story landing: full-bleed editorial hero, parallax timeline (Day 0 vs Day 180), then the live preview iframe deck with a draggable spec-fit slider revealing each self-improvement iteration. Submission form is collapsed at the very bottom, almost hidden — the story sells before the CTA.

Long-form coherent visual generation: Opus 4.7 produces the design tokens, editorial copy, AND the SVG hero illustrations for each generated preview in one pass — keeping typographic voice consistent across 6 sections of the spec-derived microsite.

One endpoint — `whyc.generate(yc_url) -> { job_id, status_url, webhook }` — with the docs page rendering a live request/response pair and a copy-paste curl snippet that actually returns a Cloud Run URL on the demo day. | surface: npm/PyPI package (`whyc`) with 3-line install, callable from Node/Python/curl. The only WhyC-owned UI is a Stripe-style docs page with live code samples — host apps own all other UX.

Long-context spec extraction over scraped JD HTML + Gemini ADK orchestration of the self-improvement loop, exposed as a single idempotent SDK call returning a job handle and webhook contract.

A single landing page that reads as a polished GitHub README: hero with one clone command, OSI-license + Apache-2.0 + Arize-track badges, 4-step pipeline as a Mermaid-style SVG, contributors row, a real-looking issue + PR snippet that reveals the self-improvement loop convergence (71 -> 96). | surface: GitHub README rendered as the landing page. Hosted Cloud Run instance is the reference impl, linked under a `// try it` badge. Stars, forks, contributors, OSI badge, clone command above the fold.

Long-context reasoning over the agent's own OpenInference traces — the README shows a real trace excerpt plus the judge's diff so anyone reading the repo can audit *why* a flow was regenerated, turning the self-improvement loop into reproducible OSS, not magic.

4일 데모: Stripe Checkout 1개 + 3-tier pricing table + 'previews used this month' 카운터 1개. 결제→웹훅→Firestore 사용량 차감→preview 생성 트리거. 환불·invoice는 Stripe 기본 UI로 위임. 그게 다. | surface: Stripe 결제 퍼스트 pricing page — 3 tier (Free / Hacker $29 / Founder $99), preview-당 usage meter 시각화, 카드 거절 시 dunning 이메일 자동, invoice PDF 다운로드, 실패한 Cloud Run 빌드는 크레딧 자동 환불

Opus 4.7의 spec→코드 변환 품질이 충분히 안정적이라 한 preview의 GPU/Cloud Run 비용을 unit economics로 예측 가능 → tier별 마진 계산이 가능 → confident pricing 가능. 또한 Phoenix self-improvement loop 수렴 횟수를 토큰 비용으로 환산해 'unlimited' 약속을 진짜로 지킬 수 있음.

• DROP live monetization from MVP. Stripe Checkout creates PCI scope on 36-day timeline. Pricing UI may be STATIC mockup only; live billing deferred post-submission.
• 'Mercenary in satire product' tone risk -- frame pricing as future-state preview, not active checkout.
• IF any payment UI ships: card data + preview URLs must NOT share tenant boundary; Stripe handles PII, WhyC stores only Stripe customer ID.

Day-4 demo: live preprint route auto-rendered from the most recent benchmark run — abstract, Figure 1 curve regenerated from real Phoenix traces, Table 1 from the eval harness, downloadable BibTeX + dataset bundle. | surface: Paper-style preprint page: abstract, Figure 1 spec-fit convergence curve (with τ-threshold and ±σ error bar), Table 1 per-cohort dataset summary, BibTeX export, references — artifact-as-evidence rather than marketing.

Opus 4.7's calibrated quantitative reasoning — generating internally consistent statistics (μ, σ, κ, n, τ), realistic convergence curves, and citation-grade prose that survives a skeptical reviewer's first read.

Day-4 demo: live HUD wired to one synthetic JD run — XP bar fills as Gemini extracts spec, four boss bars animate against real ADK stage events, Phoenix MCP spec-fit score drives the Stage-4 boss bar in real-time, and the 'Out-shipped a Series A' achievement triggers when spec-fit crosses 95%. Leaderboard is seeded fixture data. No persistence, no auth. | surface: Quest-style web HUD: top XP bar with level progression, 4-stage pipeline as boss health bars (Spec Extract → Codegen → Deploy → Phoenix Judge), live leaderboard ranking by fastest spec-fit ≥ 95%, achievement popup with rotating gold aura, draft card with rarity tag, combo streak callout. Sound-effect-ready beats marked at: Ship It button press, stage clear, achievement unlock, combo trigger, leaderboard rank-up.

Long-horizon multi-agent orchestration narrated as game mechanics — Opus 4.7 maps the self-improvement loop's iteration-until-convergence behavior onto streak/combo systems, scoring each Phoenix judge verdict as a stage-clear event and converting agent spans into player-legible progression telemetry.

Single page with: (1) hero split — 'what skeptics expect' static broken-mock SVG vs 'what WhyC actually deployed' iframe-style preview card with live URL pill; (2) objection-table with 7 rows, each row = objection / our honest answer / link to trace; (3) comparison table WhyC vs one-shot codegen vs hand-coded; (4) public known-failures log with last 3 entries. | surface: Landing page led by a 'Why you'll hate this' section listing the 7 reasons agent codegen normally fails, each crossed out with a one-line mitigation and a Phoenix trace link as evidence. Comparison table vs one-shot codegen and vs hand-coded MVP follows. Live spec-fit score and known-failure log are public.

Long-context honesty audit — Opus 4.7 reads the full Phoenix trace bundle for a run, drafts the 'where this preview is still wrong' disclosure paragraph, and refuses to publish the deploy URL until the disclosure is attached. Skepticism as a first-class output, not a footer.

Single chat thread: user pastes YC job URL → Builder agent streams 'extracting spec... deploying... judging...' with inline trace cards and a live spec-fit gauge that updates as the background self-improvement loop iterates (71% → 84% → 96%). | surface: Conversational chat surface with @mention command palette (@spec, @deploy, @judge, @rerun, @trace) as primary. The Cloud Run URL, spec-fit score, and Phoenix trace timeline render as inline chat artifacts. No structured form anywhere.

Long-context streaming narration of a multi-agent pipeline — Opus 4.7 (proxy for Gemini ADK in the actual build) maintains coherent stream-of-consciousness across 10+ min of agent steps, weaves Phoenix MCP trace IDs and judge verdicts into prose, and lets the user @mention to inject mid-flight corrections without losing pipeline state.

One screen. Paste workatastartup.com URL → Deploy. Status pill cycles through 6 deterministic stages (Queued → Extracting Spec → Generating → Deploying → Judging → Converged). Result row shows deployed Cloud Run URL + spec-fit score + elapsed time. That is the entire app. | surface: rule-based, deterministic, 사용자가 기대한 것만 정확히. Single text field for the YC posting URL, one Deploy button, one persistent status line, one resulting URL. No chat, no sparkles, no model names, no sparkle emojis, no streaming token flicker on the surface.

Opus 4.7 (server-side, invisible) handles spec extraction, codegen, and the Phoenix-fed self-improvement judging — but the surface only exposes a job queue and a URL. Capability shows up as outcome (deployed preview, spec-fit %), never as personality.

• Anti-AI minimalism risks 'forgot to design hero' read -- add ONE typographic ambition signal without breaking restraint.
• Phoenix loop hidden by design -- surface explicit /audit or /trace page so Arize-track bonus criterion is visibly demoable.