/next-dev-loop

name: next-dev-loop
description: >
  Verify Next.js runtime behavior after editing app code. Use this
  skill to confirm a change actually works in a running app — not
  just that it compiles or type-checks. Combines /_next/mcp
  (Next.js's view) with agent-browser (the browser's view).
  Requires a running `next dev`.

next-dev-loop

The edit/verify rhythm during `next dev` — make a change, then confirm it actually works at runtime, not only that the types or the build are happy.

You verify through two views of the same running app:

• **`/_next/mcp`** — an HTTP endpoint Next.js exposes about itself.

Knows framework-specific things: routes, segments, RSC, server actions, server logs, and errors as Next.js saw them. Call `tools/list` for the current surface.

• **`agent-browser`** — a CLI that drives a real Chrome. Knows

framework-agnostic browser things: DOM, console, network, React fiber, vitals. Before driving it, run `agent-browser skills get core` once for the version-matched usage guide — don't guess subcommands from memory.

The two views cross-check each other.

requires

• Next.js **16.3+** with **Turbopack** — `/_next/mcp` plus the

proactive compile check via `get_compilation_issues`.

• `agent-browser` **>= 0.31.1** — React introspection, worktree-scoped

`session id`, idempotent `--restore`, and launch flag reconciliation.

These are hard floors, not soft preferences. If anything is missing, tell the user how to upgrade and stop. Don't fall back to grepping source or to a weaker probe — this skill assumes both views are live at the versions above.

• Upgrade Next.js: `pnpm next upgrade` (or `npx next upgrade`).

Docs: https://nextjs.org/docs/app/getting-started/upgrading (version-16 guide: https://nextjs.org/docs/app/guides/upgrading/version-16)

• Install or upgrade `agent-browser`: `npm i -g agent-browser@latest`.

If the CLI isn't on `PATH`, install it before continuing — preflight expects to invoke it directly.

preflight

Once per session, confirm both views are live.

1. **Open `agent-browser` at the target URL, restoring saved login state when present.** First derive one stable session id for this checkout and use it for every `agent-browser` command:

   SESSION="$(agent-browser session id --scope worktree --prefix next-dev-loop)"
   export AGENT_BROWSER_SESSION="$SESSION"
   export AGENT_BROWSER_RESTORE="$SESSION"

Then open the target URL:

   agent-browser --session "$SESSION" --restore --headed --enable react-devtools open <url>

`--scope worktree` keeps parallel worktrees and copied checkouts from colliding. Bare `--restore` uses the session id as the persistence key, loads saved cookies/localStorage before navigation when present, and auto-saves state on close. Always pass the desired launch flags on `open`; agent-browser will reuse, relaunch, or restart its scoped background state as needed.

The browser is the user's. If state was not restored (first run, expired session) and the page is gated, the user drives the login — pause until they confirm. After login, continue using the same session and restore context; `agent-browser close` saves the cookie state so the next `open` restores it.

2. Probe `/_next/mcp` (`tools/list`) — confirm it's reachable and lists `get_compilation_issues`. First read the port off the `next dev` banner; if it isn't 3000, set `NEXT_MCP_URL=http://localhost:<port>/_next/mcp` before probing:

• Unreachable → either `next dev` isn't running, or Next.js is

below 16.3. Check `package.json` to disambiguate, then refuse.

• `get_compilation_issues` not in the list → Next.js below 16.3.

Refuse and tell the user to upgrade. 3. `get_compilation_issues` doubles as a Turbopack probe. An error response of `"Turbopack project is not available..."` means the user is on webpack. Refuse — Turbopack is required. 4. `get_routes` → your route map for the rest of the session.

loop

before the edit — narrow the scope

Ask the running app, not the codebase. `/_next/mcp` knows which files rendered the current route; use those as your search scope. Runtime introspection stays cheap as the codebase grows; agentic search doesn't.

after the edit — verify

Four failure modes. Check each:

• **Compiles** — `get_compilation_issues`.
• **Runs without errors** — `/_next/mcp` (server and bubbled-up

browser errors both surface here).

• **Behaves as intended** — `agent-browser` drives the page; assert

what the user actually sees.

• **React-level behavior** — `agent-browser` with react-devtools

enabled exposes the component tree, props, state, and render counts. Anchor framework-level checks here (extra renders, server/client boundary shifts, suspense fallbacks) — DOM asserts alone miss them.

Pick the specific tool from `tools/list` or the agent-browser manual rather than from memory.

gotchas

• **Every `agent-browser` command must know your session and restore

key, or it may use an empty default browser or fail to save login state.** Easiest: export both `AGENT_BROWSER_SESSION="$SESSION"` and `AGENT_BROWSER_RESTORE="$SESSION"` at the top of each shell you run agent-browser in. If you do not export them, pass `--session "$SESSION" --restore` on every command.

• **When the two views disagree, suspect the tooling first.** If

`agent-browser` says a route is broken but `/_next/mcp` and the server say it rendered cleanly, a stale or misdirected browser session is the likelier cause than a real bug — reconcile the views before debugging the app.

• Confirming a click or navigation: the page settles a beat later, so

wait with `wait --load networkidle` (no path to get wrong), then snapshot/read to confirm the page. Avoid `wait --url` unless you pass the link's exact href — a guessed or placeholder path won't match the real URL and times out after 25s.

• A blank read, empty snapsho