fix(live): restore prescriptive browser-open and background-poll guidance

The skill rewrite compressed two load-bearing instructions into ambient
context:

- "Navigate the browser to the URL" lost the signal that models with
  Chrome MCP should proactively open the tab before the first poll.
  Restored the forcing phrasing and the "before the first poll" anchor.
- "Claude Code can background the poll" read as permission rather than
  prescription. Models fell back to foreground blocking by default.
  Restructured harness guidance as a bulleted policy, prescriptive per
  harness, with the reason attached (harness notifies on completion so
  the conversation stays free).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Paul Bakaus
2026-04-21 14:46:18 -07:00
co-authored by Claude Opus 4.7
parent 4daabe5232
commit 62e5b2bb92
12 changed files with 60 additions and 24 deletions
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.
+5 -2
View File
@@ -9,13 +9,16 @@ A running dev server with hot module replacement (Vite, Next.js, Bun, etc.), OR
Execute in order. No step skipped, no step reordered.
1. `live.mjs` — boot.
2. Navigate the browser to the URL that serves `pageFile`.
2. Navigate to the URL that serves `pageFile` (infer from `package.json`, docs, terminal output, or an open tab). **If the session has browser automation (e.g. Claude Code / Cursor with Chrome MCP), open the tab yourself before the first poll.** Otherwise, tell the user once to open their dev/preview URL. Never use `serverPort` as that URL — it's the helper, not the app.
3. Poll loop with the default long timeout (600000 ms). After every event or `--reply`, run `live-poll.mjs` again immediately. Never pass a short `--timeout=`.
4. On `generate` — read screenshot if present; load the action's reference; plan three distinct directions; write all variants in one edit; `--reply done`; poll again.
5. On `accept` / `discard` — the poll script already cleaned up; just poll again.
6. On `exit` — run the cleanup at the bottom.
Harness: Cursor runs the poll in the foreground (blocking shell — not a background terminal, not a subagent). Claude Code can background the poll with no short timeout. Other harnesses: foreground unless the poll's stdout reliably returns to this session.
Harness policy:
- **Claude Code**: run the poll as a **background task** (no short timeout). The harness notifies you when it completes, so the main conversation stays free. Do not block the shell.
- **Cursor**: run the poll in the **foreground** (blocking shell — not a background terminal, not a subagent). Cursor background terminals and subagents do not reliably resume the chat with poll stdout.
- **Other harnesses**: foreground unless you know stdout reliably returns to this session.
Chat is overhead. No recap, no tutorial output, no pasting PRODUCT / DESIGN bodies. Spend tokens on tools and edits; on failure, one or two short sentences.