Skill instructions
mcp-ai-builder-authoring28.5 KB
View saved version →
---
name: mcp-ai-builder-authoring
description: How to build or edit an Unbounce AI Builder page through Unbounce MCP — get_ai_builder_catalog, create_ai_builder_page, get_ai_builder_document, edit_ai_builder_page, then publish_page — and what makes the page good. Use by default when the user asks to create, build, design, or generate a new Unbounce landing page (AI Builder is the default route for a new page unless the account's plan lacks it or they ask for a Classic or custom-HTML page), and whenever the page to edit, restyle, or publish is an AI Builder page, including a colleague's. Carries a menu of design-system references to style a page from.
requires:
mcpServers:
- unbounce-mcp
---
# Authoring an Unbounce AI Builder page
An AI Builder page is stored as an **editor document**: a JSON component tree
(GrapesJS project data) built from the components in the client's AI Builder
catalog and styled with the client's style guide. You author that document;
Unbounce validates it, stores it, and renders it.
## Which route
Each account in `list_accounts_and_clients` carries `builders`: whether its
plan includes AI Builder (`ai_builder`) and the Classic Builder (`classic`),
each true, false, or null when it could not be read. Read it before choosing.
- **AI Builder is the default** for a new page unless `ai_builder` is false.
- Use the Classic HTML route (`create_page_from_html`, the `mcp-page-authoring`
skill) when `ai_builder` is false, when the user asks for a Classic or
custom-HTML page, or when the catalog genuinely cannot express what was asked
for — for example a bespoke interactive widget or custom page-level
JavaScript. Not when `classic` is false: that plan has no Classic Builder.
- With both false the plan includes neither of these builders (it may still
have another, such as Smart Builder), and no page can be created here. Tell
the user.
- Tell the user which route you took and why.
- An existing page stays on the route it was built with. A Classic page is
edited with the Classic tools; an AI Builder page with the tools below.
## These pages are editable in the Unbounce AI builder
A page made or changed here is an ordinary AI Builder page. The user — and
anyone else on the client — can open it and keep editing it in the Unbounce AI
builder (`create_ai_builder_page` returns its `editor_url`). The "cannot be edited
in the Unbounce builder" rule is about **Classic pages authored from HTML only**
and does not apply here; never tell the user an AI Builder page is MCP-only.
## What does not work on an AI Builder page
These tools refuse an AI Builder page, so say so instead of trying them:
- The Classic HTML tools: `update_variant_from_html`, `create_variant_from_html`,
`bulk_edit_variants`, `get_variant`.
- `create_variant_from_existing_variant` — there is no MCP way to add a variant
to an AI Builder page.
- `set_conversion_goals` and `get_layout_hints`.
`set_variant_standing` works, with one limit on these pages: promoting the
current champion or a discarded variant is rejected
(`set-variant-standing.upstream-validation`) — bring a discarded variant back
as a challenger first. `set_page_metadata` works (see "Page metadata" below).
`set_traffic`, `set_variant_name`, `manage_page_redirect`, `get_page_stats`,
`reset_page_stats`, `unpublish_page`, and `delete_page` work as on a Classic
page. A page with no traffic recorded yet
returns `variants: []` with a `variants_unavailable` note, on any builder.
## Finding a page
`list_accounts_and_clients` returns each client with `clientUuid` and `clientId`.
Pass `clientUuid` as `client_uuid` to `list_client_pages`; `clientId` is the
numeric `context` the AI Builder tools take.
`list_client_pages` lists **Classic pages only by default**. To find an AI Builder
page — "edit my colleague's page" — pass `builder: "ai_builder"` (or `"any"` for
both). Under those scopes `total` is absent and `next_after` is a heuristic: keep
paging until `next_after` is gPreview of the first 4,000 characters. Read full instructions →
Referenced files: 59 — file references are metadata, not package contents.
mcp-feedback4.55 KB
View saved version →
---
name: mcp-feedback
description: Record a user's feedback about the Unbounce MCP tools — a bug, praise, a feature request, confusion, or anything else — straight to the team via the submit_feedback tool, with no copy/paste. Use when the user wants to report a bug, share feedback, praise something, request a feature, or flag that a tool was confusing. Also covers login/connection issues — the user can't connect the MCP in their client, sees an OAuth error ("access denied", "invalid_grant", a failed redirect), or keeps getting asked to log in again. You may also offer it after a hard MCP tool failure. It confirms the exact content with the user and redacts secrets before anything is stored.
requires:
mcpServers:
- unbounce-mcp
---
# Submit Unbounce MCP feedback
Record the user's feedback about the **Unbounce MCP tools** to the team's store by
calling the **`submit_feedback`** tool. The tool persists the record server-side, so
nothing has to be copied out of the conversation into Slack or anywhere else.
> The `mcp-` prefix here means "pertains to Unbounce MCP," not "about a page." This
> skill is about capturing feedback on the MCP tools themselves — whether they broke,
> delighted, confused, or fell short.
## Hard rule: report, don't repair
**Do NOT try to fix, retry, or work around the thing being reported.** This skill
records feedback on what already happened. Never invent tool-call arguments or error
text — anything not actually present is `unknown`. (Fixing the underlying task, if the
user wants that, is separate work done after the feedback is recorded.)
## 1. Gather the feedback
Settle two things — from the conversation where possible, asking only what you can't
infer:
- **`type`** — one of `bug` · `praise` · `feature_request` · `confusion` · `other`.
- **`message`** — the feedback in the user's own words. Keep it faithful; don't
editorialize.
For a **`bug`**, also assemble the **`context`**: the verbatim failing tool call(s)
from the transcript — exact tool name, exact arguments JSON, and the raw result/error
text (call out any `code`/`reason`/`remedy` fields). Include the relevant one(s),
especially the failing call. If the failure happened in another session and isn't in
the transcript, ask a couple of targeted questions and mark transcript-only fields
(exact arguments, exact raw error) as `unknown`. For non-bug types, `context` is
usually unnecessary — include a light pointer (the tool or page in question) only if
it genuinely helps.
**Login / connection problems** are a `bug`: capture what the user was doing, the
client they're in, and the exact error text (e.g. `access denied`, `invalid_grant`, a
failed redirect, repeated re-login prompts). Note that if the MCP can't connect _at
all_, `submit_feedback` itself won't be reachable — that's expected, and step 4's
inline fallback is how the feedback still gets out.
## 2. Redact secrets
Replace any access token, API key, password, or bearer token in the `message` or
`context` with `«REDACTED»`. Count how many you redacted. (The server re-scrubs as a
backstop, but do your pass first — the user is about to review this content.)
## 3. Confirm the exact content, then submit
Show the user the **exact record** you're about to store — the `type`, the `message`,
and the `context` if any (post-redaction) — and get an **explicit yes** before
calling the tool. This is the consent step; do not skip it and do not submit
silently. (Same ask-first bar the page tools hold for Dynamic Text Replacement.)
On yes, call **`submit_feedback`** with `type`, `message`, and `context` (if any). The
server stamps identity, timestamp, and build itself — you don't pass those.
## 4. On failure, don't lose the feedback
If `submit_feedback` fails (an error result, the tool isn't available, or an older
deploy predates it): **retry once.** If it still fails, **print the composed,
already-redacted record inline** in the conversation and tell the user to pass it to
the team directPreview of the first 4,000 characters. Read full instructions →
mcp-modernize12.5 KB
View saved version →
---
name: mcp-modernize
description: Rewrite an imported (absolutely-positioned) Unbounce Classic page variant as clean responsive HTML through Unbounce MCP. Use when the user asks to modernize a page, make a page responsive, get rid of absolute positioning, make a clean-HTML version of an existing Classic page, or edit a page that was hand-built in the Unbounce Classic builder — phrasings like "modernize this page", "make my page responsive", "convert my old page", "clean HTML version". Replication-faithful — this is a layout rewrite, never a redesign. Not for AI Builder pages, which stay editable as they are (mcp-ai-builder-authoring).
requires:
mcpServers:
- unbounce-mcp
---
# Modernizing an Unbounce page (responsive rewrite)
Turn a page built in the Unbounce builder into clean, responsive flexbox/grid
HTML — **pixel-faithful to the original on desktop, reflowing sensibly on
mobile**. This is a REPLICATION task with zero creative latitude: same copy,
same images, same fonts, same colors, same element counts. The only thing that
changes is the layout model (absolute positioning → flex/grid).
The pipeline is two deliberate stages:
1. **Import** — `create_variant_from_existing_variant` clones the builder-built
source into an MCP-managed variant that renders identically (deterministic;
every string, image URL, font, and form field lands in the copy verbatim).
2. **Rewrite** (this skill) — read that copy, restructure its layout to
responsive flex/grid, and write it back **in place** with
`update_variant_from_html`.
Extraction fidelity is stage 1's job and it is deterministic — never work from
the original builder page directly, and never re-derive content from screenshots
or memory. Your job is only the layout transformation.
## Language with the user
Never say "modernize", "modernization", "replica", or platform-internal terms
to the user. Their page is fine; say "make your page responsive" and "an
editable copy of your page". The result cannot be edited in the Unbounce
builder — all future edits go through MCP tools; say so at handover, and never
suggest the builder.
## Workflow
**Step 1 — Resolve the target.** Identify the page (`list_client_pages`) and
variant (`list_page_variants`). If the target variant is builder-built (not
MCP-managed), tell the user in one line what is about to happen — e.g. _"I'll
create an editable copy of your page, then make that copy responsive — your
original stays untouched"_ — then run `create_variant_from_existing_variant`
(no `target_page` ⇒ new page). No further permission ceremony is needed; the
copy is additive and safe. Relay any conversion warnings honestly. A
fixed-width "autoscale" source converts fine — the conversion report notes that
runtime viewport scaling isn't preserved; that is expected and harmless here,
because you rewrite the page responsive from scratch (Step 4), discarding the
scaling entirely. If the target is already an MCP-managed imported copy, skip
straight to Step 2.
**Step 2 — Read the copy.** `get_variant` on the imported variant. Download the
`html_ref` / `css_refs` sources and any `scripts` entry's `ref` (via `download`, or
`download_inband` if you cannot run shell commands). This body is the **sole
source of truth** for every value: copy strings, image URLs (with their
`srcset`), `@font-face` blocks, colors, dimensions, form fields, `<ub:dynamic>`
tags. Never guess a value, never take one from a screenshot, never reconstruct
from memory. If the copy came from an autoscale source, its CSS wraps lengths in
`calc(<px> * var(--scale, 1))` and it may carry a viewport scale script —
ignore both: read the plain px value (the `* var(--scale)` is the fixed-width
scaling you are removing) and never copy the scale script into the rewrite. Your
responsive layout comes from the Step 3 rows, not these fixed dimensions.
**Step 3 — Get the layout skeleton and fidelity signals.** `get_layout_hints`
on the same variant. It returns, per section: `rows` Preview of the first 4,000 characters. Read full instructions →
Referenced files: 5 — file references are metadata, not package contents.
mcp-page-authoring27.2 KB
View saved version →
---
name: mcp-page-authoring
description: Best practices for authoring a Classic Unbounce landing page from HTML/CSS/JS through Unbounce MCP — create_page_from_html, create_variant_from_html, and update_variant_from_html. Use when the user asks for a Classic or custom-HTML page, when a new page needs something the AI Builder catalog cannot express (a bespoke interactive widget, custom page-level JavaScript), when the account does not have AI Builder, or to edit or add a variant to a page already authored through these HTML tools; also to personalize page text by URL parameter (Dynamic Text Replacement). A new page otherwise goes through the mcp-ai-builder-authoring skill. Not for AI Builder pages or pages hand-built in the Unbounce builder.
requires:
mcpServers:
- unbounce-mcp
---
# Authoring an Unbounce MCP page
These rules apply when you write the HTML/CSS/JS body for `create_page_from_html`,
`create_variant_from_html`, or `update_variant_from_html`. The page is a full-bleed
custom-HTML page — you own the markup end to end. Design the page to be optimized
for conversions: by default, every layout, copy, and hierarchy decision should
serve the page's single conversion goal.
This covers **MCP-authored pages only**, and the split is exclusive both ways:
- A page hand-built in the Unbounce builder is not editable this way —
`update_variant_from_html` refuses it. Replicating or modernizing a
builder-built page is a different, audit-first job.
- An MCP-authored page **cannot be edited in the Unbounce builder**. Never tell
the user they can open, tweak, swap images, or finish the page "in the
Unbounce builder/editor" — they cannot. Every edit goes through these MCP
tools: the user asks for the change, or supplies updated HTML.
AI Builder pages (`create_ai_builder_page`, `edit_ai_builder_page`) are a separate
route covered by the `mcp-ai-builder-authoring` skill; they stay editable in the
Unbounce AI builder, so the rule above does not apply to them.
A new Classic page needs the Classic Builder on the account's plan: check
`builders.classic` for the client's account in `list_accounts_and_clients`. When
it is false, take the AI Builder route instead and tell the user why;
`create_page_from_html` refuses such an account before anything is uploaded,
with `create-page-from-html.classic-builder-not-entitled`, or
`create-page-from-html.no-builder-entitled` when the plan has neither builder. A
`create-page-from-html.not-author-or-not-entitled` at the create means the user
is not an author on the client or the plan lacks the Classic Builder; `builders`
tells them apart.
## Updating a variant: HTML/CSS replace, JS is left alone
`update_variant_from_html` full-replaces the body HTML and the stylesheet, so
send every stylesheet the variant should keep on every call. **JavaScript is the
exception: omit `scripts` and the variant's existing custom-JavaScript elements
are kept**, reported back as `scripts_preserved`.
That matters because a variant can carry scripts nobody authored through these
tools — an **Unbounce popup** attaches itself as one. So:
- Editing HTML or CSS? Just omit `scripts`. The popup and anything like it
survive, and you don't need to know they were there.
- Changing the scripts? Pass `scripts` with the **complete** desired set — it
replaces all of them, including external includes. Whatever it drops comes
back in `removed_scripts`. Those entries — and the `scripts_preserved` ones —
are already in `scripts` entry form: pass one straight back to restore it,
unchanged, no translation. A plain include appears as `src` (with `async` /
`defer` if it had them); everything else — including an include whose tag
carries other attributes, such as a `data-*`-configured analytics embed — comes
back as verbatim `tag`. Read the variant first
(`get_variant`) if you don't know what's there.
- Removing every script is deliberate: pass `scripts: []`.
## Writing a `scripts` entry
Each entry is one cuPreview of the first 4,000 characters. Read full instructions →
Referenced files: 2 — file references are metadata, not package contents.