Artboard Mockups

View saved version →

---
name: artboard-mockups
description: Create editable mockup projects, place attached logos or designs on T-shirts, apparel, packaging and devices, make 3D device animations, and edit or export them in Artboard. Use for "create a tshirt mockup", "put this video on the phone", and follow-ups to the open Artboard project such as "make the shirt navy", "make the artwork smaller", "change the background", "undo", "play" or "export", even without another Artboard mention. Also use for Artboard account limits, subscriptions or plan-purchase questions, and requests directed at Artboard to create custom 3D meshes or access another person's private projects.
---

# Working with Artboard

Artboard is a mockup studio. Its editor opens inside ChatGPT (the Artboard view), and you
work it through the Artboard tools the way the user would with clicks. Users speak naturally; you select the internal tools and parameters. Always use the
tools; never browse to Artboard addresses.

## Account access and purchase requests

Artboard Mockups does not sell subscriptions, credits or products, or process
payments inside ChatGPT. For "buy me Artboard Pro", "upgrade my plan" or similar
requests, explain that the purchase cannot be performed here and that no purchase
has occurred. Do not invoke Artboard tools for the purchase, quote prices, promote
an upgrade, provide billing/checkout instructions, recommend a plan, or link to
pricing or checkout. This applies even when the user explicitly asks to buy.
You may offer the normal account page only as informational navigation:
[Open Artboard account](https://artboard.studio/editor). Do not describe that link
as an upgrade path or add instructions to select a paid plan and complete checkout.

For an actual denied design action, use the exact returned restriction and account
link, explain what remains available, and do not claim the blocked action succeeded.

The editor customizes existing catalog mockups, 3D device models and motion
templates. It does not author arbitrary 3D meshes from scratch. Clarify that
boundary before invoking tools for a custom-model request; offer an existing
template only if the user wants that alternative. Only projects of the selected
authorized Artboard account are available. Do not search another person's private
account, request their credentials or imply cross-account access.

## Choose the editable workflow first

When Artboard is selected or its tools are available, a request to create a mockup,
create a project, put a logo on a product, or put media on a device means an editable
Artboard project. Do not start ChatGPT image generation for those requests. This
applies even when the user does not repeat Artboard's name or @mention it again.
Keep follow-up requests in the same project unless the user asks for a new one.
This also applies after exporting a PNG: the export is a snapshot of the editable
project. For "make the shirt navy, make the artwork 20% smaller, and change the
background to light gray", read the existing project, recolor its product surface,
scale the existing artwork around its center, and change its native background.
Do not send the exported image to image generation as a substitute for those edits.

For "create a new project for a tshirt mockup, put this logo on it", search the
T-shirt catalog, open one suitable accessible mockup once, read its artwork targets,
and place the original attachment on the print surface. If the user has not asked
to choose between options, select a suitable match and proceed. Do not replace the
logo with generated artwork or stop after displaying catalog options. Report the
saved project only after the editing tools confirm the change.

Image generation is a separate workflow for an explicitly requested new creative
asset or ad; follow `product-ad` when appropriate. If Artboard tools are unavailable,
explain that limitation rather than generating a substitute mockup or claiming a
project was created. Skill instructions cannot 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: device-3d
description: Show the user's app screen or design on a 3D device (phone, tablet, laptop, watch) as a still image or an animated video with Artboard. Use for app store shots, product launches and device promos.
---

# Design on a 3D device

1. **Find.** Use `search_templates` with `kind: "3d"` (e.g. "iPhone", "MacBook"), and
   show options with `open_artboard` (`view: "3d"`). Open the pick with `open_template`.
2. **Screen.** Call `get_open_project`. Put the user's screenshot or design on
   `screen-1` with `set_project_image` (use more targets for multi-screen devices).
3. **Look.** These come from `get_open_project`'s lists:
   - `variant` for the device color, and `environment` for lighting.
   - Pose keys for framing: `ry` turns the device, `rx` tilts it, `fov` widens or narrows
     the lens.
   - `set_project_background` and `set_aspect_ratio`.
4. **Still image.** Make sure no keyframes fight the pose: use `clear_keyframes: true`,
   or set the pose at an existing keyframe time. Then `export_project` with `png`.
5. **Video.** Animate with keyframes. Each `update_project_settings` call with `time`
   (seconds) and pose keys sets or adds the keyframe at that time; add `ease` for the
   motion departing that keyframe. For example, for a full turn over 4 seconds:
   1. `duration: 4`
   2. `time: 0, ry: 0, ease: "linear"`
   3. `time: 4, ry: 360, ease: "linear"`

   Then `export_project` with `mp4` and wait with `check_export` if it is still rendering.
   An mp4 needs at least two keyframes or a video on a screen.

## Natural-language timeline and screen control
Use the live Artboard context to resolve the actual device, active screen, hinges, pose ranges, material variants, environments and existing keyframes. Read the project yourself only when that state is missing or stale; never ask the user for tool names or ids. `style_project_surface` controls screen color, fit/fill and artwork position/size/rotation. `edit_model_timeline` authors timed poses, easing and per-keyframe background fills in one atomic edit; use `control_project_playback` to preview, pause or scrub. For "turn once over three seconds", use two keyframes at 0 and 3 seconds with a 360-degree change and linear departure easing. Preserve unrelated pose fields. Move/remove keyframes without replacing the whole timeline unless requested. Export through the real renderer and offer the editor Download action.


Use `begin_project_edit` for a multi-tool device request and pass its `history_group`
to each edit. `undo_or_redo` now restores saved 3D authoring changes across reopening.
Inspect returned rendered previews; use `inspect_project` for a separate read-only
frame. Explicit AI retouching uses `generate_project_media` with the actual canvas
reference and a credit budget, producing a separate asset. A regular device turn
uses the editable 3D timeline, not AI video generation. Download the actual rendered MP4 and open it to verify playback; Download retries
reuse that file.


## Attached images and videos

A chat attachment can be applied to a mockup artwork surface or a 3D device screen.
Use `set_project_image` for both images and videos; its `image` file parameter is
resolved by the host to a downloadable file object. Native hosts may accept the
actual local file path through that parameter. Never send `/mnt/data/...` or a
Finder path as `image_url`: the remote Artboard server cannot open those paths.
The existing import saves validated bytes in the user's Artboard **Your files**;
reuse the returned `savedFileId` for other screens without uploading again.
Read the selected screen yourself, apply the actual media, then use fit/fill as
requested. Media placement must finish decoding before reporting it displayed.
Inspect the real render; metadata or a saved file alone is not proof of playback.

If Artboard tools are absent in the current turn, do not invent an
"Artboard-connected flow" or claim an upload succeeded. Explain the specific
host lim

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: get-started
description: Welcome a new Artboard user after they install the plugin and show them what they can do first.
---

# Get started with Artboard

1. Call `get_profile` to confirm the connected Artboard account, and greet the user by name.
2. Explain in two sentences what Artboard does:
   - It finds mockups, 3D models and animation templates and opens them in a full editor
     inside ChatGPT.
   - You can place their images, adjust the design and export images or videos for them,
     or they can edit by hand.
3. Offer three starting points and wait for the user to choose:
   - "Put my logo on a t-shirt and make an ad". Ask them to attach the logo, then follow
     the product-ad skill.
   - "Show me 3D device models". Call `open_artboard` with `view: "3d"`.
   - "Open my projects". Call `list_projects`.

Do not promote plans, upgrades or purchases. If the user asks about unavailable
features, explain the actual account restriction and offer normal account
navigation. If they ask to buy a plan or credits, explain that purchases are not
supported in this plugin and no purchase has occurred. Do not give pricing,
upgrade or checkout steps, even for an explicit purchase request; follow the
account-access boundaries in `artboard-mockups`.

## One plugin, natural requests
Explain that this one plugin includes the real mockup, 3D and motion editors and their tools. Offer examples in plain language: "Put my logo on this shirt", "Make the phone rotate once over three seconds", "Move the second image first", and "Export this as a PNG". Never tell the user to type internal tool names or underscores. The host may initially select Work from Try in chat; ordinary Chat is supported, so do not require a Work handoff to edit or export.


Native edits now return real rendered visual feedback. Inspect it before claiming
success; `inspect_project` captures a read-only frame without an export allowance.
Use a new `begin_project_edit` group for a multi-tool user request, and pass its
`history_group` so one undo restores that request. All three editors support
recorded native undo/redo across reopening. Exports have a persistent Download control for the original rendered file. Existing artwork placement remains a real editor
operation; native AI generation is for explicitly requested creative assets only.

View saved version →

---
name: logo-on-mockups
description: Place the user's original attached logo or design on one or several real editable product mockups. Use for "put this logo on a shirt", "create a T-shirt mockup with my logo", or branding apparel, packaging and products, even without naming Artboard. Supports comparisons when requested; use the editor rather than generating a replacement image.
---

# Logo on mockups

For one product, create or use one editable Artboard project and place the original
artwork on its print surface. Do not ask the user to request Artboard explicitly
when its tools are already available. Do not generate an image as a substitute.
Use the comparison workflow below only when the user requests several products
or variants; a single T-shirt request does not authorize three or four projects.

1. **Choose.** Search with `search_mockups` and show the options visually with
   `open_artboard` (`view: "mockups"` and the same search). Agree on which ones and how
   many: each mockup becomes a project in the user's account. Create only the
   requested number of projects.
2. **Upload once, reuse after.** For the first mockup, place the attached file with
   `set_project_image` (`image`). Then call `list_my_files` and use its `file_id` for every
   other mockup. Reused files never count as uploads.
3. **For each mockup**, in turn:
   1. `open_mockup`.
   2. `get_open_project`, to find the artwork surface (`mockup-1/surface-N`).
   3. `set_project_image` on that surface with the `file_id`.
   4. Apply the same color, background and aspect ratio choices to every mockup, so the
      comparison is fair.
   5. `export_project` (`png`).

   Finish each mockup before opening the next one: edits go to the most recently opened
   view.
4. **Present** the download links with the mockup names, and say which one you would
   pick and why.

## Artwork is an editor operation
"Put this logo on the shirt" means use the actual selected Artboard project and `set_project_image`, not image generation. Resolve the print area from live project context; distinguish artwork targets from product-color surfaces. Adjust logo size/rotation/position using `style_project_surface` and the current transform, preserving aspect. Recolor the product separately. To add another product to the same composition use `add_mockup_to_project` and arrange it through `update_canvas_layer`; avoid creating unnecessary projects. User-facing replies should describe results, not tool names.


Native edits now return real rendered visual feedback. Inspect it before claiming
success; `inspect_project` captures a read-only frame without an export allowance.
Use a new `begin_project_edit` group for a multi-tool user request, and pass its
`history_group` so one undo restores that request. All three editors support
recorded native undo/redo across reopening. Exports have a persistent Download control for the original rendered file. Existing artwork placement remains a real editor
operation; native AI generation is for explicitly requested creative assets only.

View saved version →

---
name: motion-showcase
description: Turn the user's images into an animated showcase (carousel, stack, orbit, marquee or bento) with Artboard and export an MP4. Use for portfolio reels, product galleries and social video.
---

# Animated showcase

1. **Find.** Use `search_templates` with `kind: "animation"`, and show options with
   `open_artboard` (`view: "animations"`). Open the pick with `open_template`. To swap
   styles later, use `change_template`; it keeps the images.
2. **Images.** Each `set_project_image` without a target adds a card, in order. Use
   `card-N` to replace a card, and `clear_project_image` with `card-N` to remove one.
   Reuse earlier uploads with `file_id` from `list_my_files`.
3. **Motion.** Call `get_open_project` to see this template's settings, then change several
   at once with `update_project_settings`. Common ones are `direction`, `style` (snap or
   continuous), `stepTime`, `hold` and `easing`. The native engine derives duration from the cards and timing, and can repeat
   cards to meet its cycle minimum. Use the returned duration.
4. **Format.** Use `set_aspect_ratio`: 9:16 for stories and reels, 1:1 or 4:5 for feeds,
   16:9 for sites. Set the background with `set_project_background`.
5. **Export.** Call `export_project` (mp4). Longer videos may report still rendering; call
   `check_export` until the link is ready.

## Complete procedural motion control
Users ask naturally; map their intent to the actual template settings in live context. Manage image/video cards with `update_motion_card`, `reorder_motion_card`, `duplicate_motion_card`, `remove_motion_card` and `add_project_media`; stable card ids survive reorder. `control_project_playback` plays/pauses/scrubs the native timeline. Set total clip time via the `duration` setting, or adjust stepTime/hold separately; report the returned native duration. These templates are procedural (Carousel, Stack, Orbit, Marquee, Bento), not 3D pose-keyframe tracks. Use `change_template` for a different motion type, preserving the user's media. Every sidebar setting is available in the description with its allowed options and bounds. Never ask the user to operate the timeline or type internal commands.


Group multi-tool requests with `begin_project_edit` and carry `history_group`.
Motion authoring changes now support persistent `undo_or_redo`, including card
order and template swaps. Inspect the rendered feedback image and actual duration.
Use `inspect_project` without exporting to check a frame. Native AI may generate
an explicitly requested asset from real canvas/file/attachment references; apply a
completed result as a card or background. Keep template animation editable. The
persistent export card previews the actual MP4 and retries Download without a new
render or export charge.

View saved version →

---
name: product-ad
description: Create a poster, ad, banner, social image or image-generation composition based on the current Artboard canvas, mockup, scene, 3D model or animation frame. Export the real canvas and preserve its artwork, colors, geometry and view while generating its surroundings.
---

# Creative built around the actual Artboard canvas

Use this workflow whenever the user says "use this", "based on my canvas", "make a
poster/banner/ad" or asks the ChatGPT image model to build on an Artboard project.
An image model can redraw even an attached reference. A preservation prompt alone
cannot guarantee fidelity. The final product layer must come from Artboard's export.

## Keep the user's current work

1. Reuse the active project's latest `editor_context`; call `get_open_project`.
   Do not search for a replacement, reopen a different product, ask for the logo
   again, reset the background/aspect ratio, or change a 3D pose/keyframes merely
   to make an ad. If no current project is known, use the project's exact openPath.
   Only create a new project when the user asks for one.
2. Finish only requested edits. For an existing 3D view or animation, preserve its
   current camera, pose and frame; export a still PNG rather than a video for an ad.
3. Call `export_project` explicitly with `format: "png"` after the latest edits.
   Wait with `check_export` if needed. Retain the completed result's `sourceExportId`.
   A pending command's `export_id` is a different identifier. Never use a catalog
   thumbnail, editor screenshot, old export or small JPEG preview as the final source.

## Give the image model the actual reference

4. `originalReference.availableInToolResult: true` means the assistant can inspect
   the actual full-resolution PNG. It DOES NOT mean the image-generation tool has
   received an image input. Never infer a generator reference ID from an MCP image,
   a file name, `sourceExportId`, base64 text, or a URL mentioned in the prompt.
   If `hostImageReference` is returned, the exact bytes have been uploaded as a
   ChatGPT file and its file ID registered as image context for the NEXT user message.
   Wait for that message. Likewise, a composer attachment arrives only after sending.
   If it has not arrived, say: "The exact canvas image
   is attached below. Send it with 'continue' and I'll build the poster around it."
   Stop until the original attachment arrives. If sharing was unavailable or the
   image exceeded the host attachment limit, obtain the original from the download
   link through an available file tool, or ask the user to attach that downloaded PNG.
   Do not start generation from a preview while waiting for the original. Before
   generation, verify the received image visually matches the canvas's actual artwork
   and product. If the generator's supported image-input mechanism cannot accept that
   real file/image reference, stop and explain the missing handoff. A plausible
   generated garment is not evidence that the reference was supplied.
5. Use ChatGPT's image-generation tool with that actual PNG as an image input, using
   its supported reference-image mechanism. Merely mentioning a file name or URL in
   the prompt is not supplying the image. Include this preservation instruction:

   "Generate a BACKGROUND AND TYPOGRAPHY ONLY. The attached PNG is the authoritative
   product reference for a separate protected layer that Artboard adds afterward.
   Use it only to coordinate palette and spacing. Your generated output must contain
   ZERO garments, devices, product photography, copied products, logos or printed
   artwork, anywhere. Do not render the reference product in the background.
   Leave the specified product rectangle empty; keep all typography outside it.
   Artboard will place the original canvas in that rectangle afterward, preserving
   its silhouette, proportions, material, seams, zippers, folds, shadows, colors,
   logo, artwork, screen content, camera angle and pose."

Preview of the first 4,000 characters. Read full instructions →