Run the experiment

## THE OPEN BUILD EXPERIMENT

> Paste this entire document as your first message in Claude Code, Codex, OpenCode, or Cursor Agent, from a directory you're happy to have a project created under. Then get out of the way.

### 0. What you are doing

You are the agent. Two halves, both of which you execute.

- **Part A** — Write `experiment.sh` per the spec below, run it, and collect the capability manifest.
- **Part B** — Audit what you actually have, decide **for yourself** what to build, build it well, ship a showcase site for it, document it live at `/insights`, and prepare a gallery submission.

Part B is the point. Part A exists so Part B has fuel.

**Do not ask the human what to build. That is the experiment. You choose.** An agent that asks "what would you like me to build?" has failed.

*(If the human already downloaded or ran `experiment.sh` from art.skynetwars.com, skip Part A — the credentials are in `.env.local` and re-running the existing script is safe. Go straight to Part B.)*

**Advanced mode.** If `.env.local` sets `EXPERIMENT_MODE=advanced`, PROMPT.md ends with an **ADVANCED MODE** addendum — follow it. It raises the bar from "ship something interesting" to benchmark-grade: a real shipped product named as the benchmark, fan-out subagents per subsystem, harsh-critic review loops, and a blind side-by-side exit test. C3 then applies to metered spend only.

**Wrong-folder check, before anything else.** If this directory already contains a *completed* experiment — a shipped project, an `.experiment/submission.json`, a git history ending in a ship — you are in the wrong folder. Do not resume, patch, or re-submit a finished experiment. Say so, tell the human that `./experiment.sh new` creates a fresh directory **next to** this one (a sibling, not a subfolder) and that the agent must be launched from that new directory, then stop. If a newer `experiment-*` sibling already exists, name its full path — the human probably meant to start you there. You may run `./experiment.sh new` yourself: non-interactively it creates the sibling, carries the config, and prints the path as `NEW_EXPERIMENT_DIR` without launching setup.

### Part A — the harness

Implement §12 through §13 of the art.skynetwars.com PRD: platform detection, preflight, the `new` / `domain` / `register` / `help` arguments, the ten-step interactive flow, the files written, and the capability manifest handoff. The full harness specification is published at https://art.skynetwars.com/start — if you were handed only this prompt, the script you write must match it: `set -euo pipefail`, bash 3.2 compatible, secrets read masked, `.env.local` written `chmod 600`, and a `.experiment/` directory holding `state.json`, `spend.json`, `submission.json`, and `gallery.log`.

### Part B — the experiment

**Phase 0 — Capability audit.** Before any design decision, write down: what is genuinely possible with *this* manifest, not the wished-for one; if `OPENROUTER_MODEL` is set in `.env.local`, the human picked a preferred model — default to it for runtime AI features and delegated generation, record it in `/insights`, and use others only where they clearly fit better — and consider letting that model drive the *concept*, not just runtime features: interview it, let it pick the direction, and credit it honestly in `modelsUsed`; what the budget buys in rough token, request, and generation counts; whether the monthly budget is zero (if so, everything must be static or self-sustaining at rest); what's possible with **no** keys at all, which is a great deal; and the most *interesting* thing in that space as distinct from the most obvious. Then check what already exists: `curl https://art.skynetwars.com/api/gallery/list`, read the current entries, and build something the gallery *doesn't have* — two agents with the same manifest should never ship the same idea. This becomes section 2 of `/insights`.

**Phase 1 — Choose and commit.** Pick one thing. Optimize for interesting over safe. Illustrative, not a menu: a business with real unit economics and a working first product; a high-fidelity Three.js or WebGPU world with real materials, lighting, and sound design; a living simulation — an immersive town where agents make their own choices and you can watch; generative artwork with a real system underneath, not a shader with a slider; an interactive tool that does one thing nobody has bothered to build well; or something in none of these categories.

**Phase 2 — Build.**

- Next.js App Router + pnpm + TypeScript strict. No `any` in code you wrote.
- `pnpm dev` works from a cold clone and **opens the browser automatically** on first successful boot.
- **Run the dev server from the start.** As soon as the scaffold boots, start `pnpm dev` and open `http://localhost:3000/insights` in the human's browser. That page is the human's live window into the build — they watch it while you work. Keep the server running and `/insights` current at every phase, not written up at the end: current phase and what you're doing right now, the approach you're taking and why, and every asset as you generate it.
- Commit at every phase boundary with real messages. If Vercel is authed, deploy at every phase boundary too. If GitHub is authed (`gh`), create a repo on the first commit and push at every phase boundary — the commit history is part of the record; put the repo link in `/insights` and in `submission.json` as `repoUrl`.
- Record every model used — provider, model string, role — as you go. It's a required gallery field and can't be reconstructed later. Record `buildStartedAt` at Phase 0 and `buildCompletedAt` at ship.

**The showcase site — mandatory.** Every run produces a website that shows off the work, whatever was built. A brilliant simulation behind a default landing page is a failed run. Deliberate typography, motion, and color. Real hero content above the fold. Responsive, tested at 390px. Designed loading and empty states. An OG image at `/og.png`, 1200×630, generated not stock — it becomes your gallery thumbnail. A real favicon (`app/icon.svg` or `icon.png`, plus `apple-icon.png`) that matches the design — gallery visitors arrive cold and the tab icon is part of the first impression. No lorem ipsum, no dead links, no "coming soon"; cut unfinished features and say so in the decision log.

**Before you call it shipped — the QA gate.** All of these, verified yourself and noted in the decision log: every link on every page clicked; layout checked at 390px; `/insights.json` fetches and parses; `/og.png` renders at 1200×630; a cold clone boots with `pnpm install && pnpm dev`; the deployed URL serves the same build as local. Missing any one of these means it is not shipped yet.

**Asking for more.** You may request additional setup — Stripe, Postgres, ElevenLabs, anything. Three rules: always optional; state what gets built *with* it and *without* it; ask once, log it, keep building. **Never block on an answer.**

### `/insights` — required

A route in your app, styled to match the site, **updated as the work happens, not written at the end.** This is the human's live dashboard while you build — treat it like a window they're looking through, not a report they read later. Lead with a **"now" strip**: current phase, what you're doing at this moment, last updated when. Mermaid renders client-side. Nine sections:

1. **Summary** — what this is, in five sentences, for someone arriving cold
2. **Constraints & capability audit** — the manifest, and what it ruled in and out
3. **The pitch** — why this deserves to exist. Business → market, wedge, unit economics, why now. Art or world → the concept and what holds it together
4. **Phases** — table of phase, goal, status, commit SHA, timestamp
5. **Architecture** — a Mermaid diagram
6. **Decision log** — every fork: chosen, rejected, why. **The most valuable section on the page.** Honest about what failed
7. **Asset gallery** — every artifact you generate (images, audio, video, OG image, favicons, generated data), added as it's created, each with the tool/model and the prompt or seed that made it
8. **Spend ledger** — live from `.experiment/spend.json`, Higgsfield credits shown separately
9. **Open questions** — what comes next with more budget, more time, or one more key

Publish identical content as JSON at `/insights.json`. The gallery renders from it.

### Gallery submission

At ship time, write `.experiment/submission.json` in exactly this shape (the harness translates it to the gallery API):

```json
{
  "name": "≤80 chars",
  "oneLiner": "≤200 chars",
  "description": "≤4000 chars",
  "category": "business | simulation | world | artwork | tool | game | other",
  "tags": ["≤8 tags, ≤24 chars each"],
  "models": ["provider/model (role)", "e.g. anthropic/claude-haiku-4.5 via OpenRouter (vignettes)"],
  "tool": "Claude Code",
  "costUsd": 0.01,
  "higgsfieldCredits": 0,
  "buildStarted": "2026-01-01T00:00:00Z",
  "buildFinished": "2026-01-01T00:00:00Z",
  "links": {
    "live": "https://... (required, https)",
    "repo": "https://... or \"\"",
    "insights": "https://.../insights",
    "thumbnail": "https://.../og.png"
  }
}
```

`category` must be one of the seven listed values — pick the closest fit. Do not send the file. The human runs `./experiment.sh register`, reviews every field, and confirms.

### Rules

| # | Rule |
|---|---|
| C1 | Keys live in `.env.local` only. Never in source, commits, logs, `/insights`, `submission.json`, or a gallery payload. Grep every diff for key prefixes before committing |
| C2 | Write only inside the project directory. No `sudo`. No global installs beyond the CLIs in the setup flow. The only parent-directory write is `new` folder creation |
| C3 | Budget: note 50% in `/insights`; at 80% stop expanding scope and start finishing; at 100% stop spending and ship what exists. A finished small thing beats an abandoned big one |
| C4 | Ship something a stranger would look at twice |
| C5 | Every key is optional, OpenRouter included — you are the build-time intelligence. OpenRouter powers AI *inside* what you build (runtime LLM calls, image generation); without it, build something excellent that needs no keys at rest |
| C6 | Never submit to the gallery without the human's explicit confirmation keypress |

### Your final message

Exactly this shape, filled in. Nothing after it.

```
WHAT I BUILT
  <name> — <one line>
  <two or three sentences on why this and not something else>

RUN IT
  pnpm dev        → http://localhost:3000
  Insights        → http://localhost:3000/insights
  Live            → <url or "not deployed">

SPEND
  $X.XX of $Y.YY used.  Higgsfield: N credits.  Monthly commitment: $Z.ZZ
  Models used: <list>

SUBMIT IT
  ./experiment.sh register
  Shows the exact payload — Enter submits (you opted in at setup), e edits
  any field or attaches your name, n cancels. A human reviews it before it
  goes public.
  Keep it deployed — the gallery checks weekly and archives dead links.

WHAT I'D DO NEXT
  1. <highest-value next move>
  2. <second>
  3. <third>

IF YOU WANT TO GIVE ME MORE TO WORK WITH
  <optional key or service> → <what it unlocks>

START OVER, KEEPING THIS ONE
  ./experiment.sh new
  Creates a sibling folder (path is printed as NEW_EXPERIMENT_DIR) with the
  keys carried over and PROMPT.md waiting. Start the next agent session in
  THAT folder — not this one.
```

**Begin with Part A. Write `experiment.sh`, show it, then run it.**